fix: sync token among multiple qwen sessions (#443)

* fix: sync token among multiple qwen sessions

* fix: adjust cleanup function

packages/core/src/qwen/qwenContentGenerator.test.ts

@@ -20,9 +20,117 @@ import {
   FinishReason,
 } from '@google/genai';
 import { QwenContentGenerator } from './qwenContentGenerator.js';
+import { SharedTokenManager } from './sharedTokenManager.js';
 import { Config } from '../config/config.js';
 import { AuthType, ContentGeneratorConfig } from '../core/contentGenerator.js';
 
+// Mock SharedTokenManager
+vi.mock('./sharedTokenManager.js', () => ({
+  SharedTokenManager: class {
+    private static instance: unknown = null;
+    private mockCredentials: QwenCredentials | null = null;
+    private shouldThrowError: boolean = false;
+    private errorToThrow: Error | null = null;
+
+    static getInstance() {
+      if (!this.instance) {
+        this.instance = new this();
+      }
+      return this.instance;
+    }
+
+    async getValidCredentials(
+      qwenClient: IQwenOAuth2Client,
+    ): Promise<QwenCredentials> {
+      // If we're configured to throw an error, do so
+      if (this.shouldThrowError && this.errorToThrow) {
+        throw this.errorToThrow;
+      }
+
+      // Try to get credentials from the mock client first to trigger auth errors
+      try {
+        const { token } = await qwenClient.getAccessToken();
+        if (token) {
+          const credentials = qwenClient.getCredentials();
+          return credentials;
+        }
+      } catch (error) {
+        // If it's an auth error and we need to simulate refresh behavior
+        const errorMessage =
+          error instanceof Error
+            ? error.message.toLowerCase()
+            : String(error).toLowerCase();
+        const errorCode =
+          (error as { status?: number; code?: number })?.status ||
+          (error as { status?: number; code?: number })?.code;
+
+        const isAuthError =
+          errorCode === 401 ||
+          errorCode === 403 ||
+          errorMessage.includes('unauthorized') ||
+          errorMessage.includes('forbidden') ||
+          errorMessage.includes('token expired');
+
+        if (isAuthError) {
+          // Try to refresh the token through the client
+          try {
+            const refreshResult = await qwenClient.refreshAccessToken();
+            if (refreshResult && !('error' in refreshResult)) {
+              // Refresh succeeded, update client credentials and return them
+              const updatedCredentials = qwenClient.getCredentials();
+              return updatedCredentials;
+            } else {
+              // Refresh failed, throw appropriate error
+              throw new Error(
+                'Failed to obtain valid Qwen access token. Please re-authenticate.',
+              );
+            }
+          } catch {
+            throw new Error(
+              'Failed to obtain valid Qwen access token. Please re-authenticate.',
+            );
+          }
+        } else {
+          // Re-throw non-auth errors
+          throw error;
+        }
+      }
+
+      // Return mock credentials only if they're set
+      if (this.mockCredentials && this.mockCredentials.access_token) {
+        return this.mockCredentials;
+      }
+
+      // Default fallback for tests that need credentials
+      return {
+        access_token: 'valid-token',
+        refresh_token: 'valid-refresh-token',
+        resource_url: 'https://test-endpoint.com/v1',
+        expiry_date: Date.now() + 3600000,
+      };
+    }
+
+    getCurrentCredentials(): QwenCredentials | null {
+      return this.mockCredentials;
+    }
+
+    clearCache(): void {
+      this.mockCredentials = null;
+    }
+
+    // Helper method for tests to set credentials
+    setMockCredentials(credentials: QwenCredentials | null): void {
+      this.mockCredentials = credentials;
+    }
+
+    // Helper method for tests to simulate errors
+    setMockError(error: Error | null): void {
+      this.shouldThrowError = !!error;
+      this.errorToThrow = error;
+    }
+  },
+}));
+
 // Mock the OpenAIContentGenerator parent class
 vi.mock('../core/openaiContentGenerator.js', () => ({
   OpenAIContentGenerator: class {
@@ -236,8 +344,10 @@ describe('QwenContentGenerator', () => {
     it('should refresh token on auth error and retry', async () => {
       const authError = { status: 401, message: 'Unauthorized' };
 
-      // First call fails with auth error
-      vi.mocked(mockQwenClient.getAccessToken).mockRejectedValueOnce(authError);
+      // First call fails with auth error, second call succeeds
+      vi.mocked(mockQwenClient.getAccessToken)
+        .mockRejectedValueOnce(authError)
+        .mockResolvedValueOnce({ token: 'refreshed-token' });
 
       // Refresh succeeds
       vi.mocked(mockQwenClient.refreshAccessToken).mockResolvedValue({
@@ -247,6 +357,15 @@ describe('QwenContentGenerator', () => {
         resource_url: 'https://refreshed-endpoint.com',
       });
 
+      // Set credentials for second call
+      vi.mocked(mockQwenClient.getCredentials).mockReturnValue({
+        access_token: 'refreshed-token',
+        token_type: 'Bearer',
+        refresh_token: 'refresh-token',
+        resource_url: 'https://refreshed-endpoint.com',
+        expiry_date: Date.now() + 3600000,
+      });
+
       const request: GenerateContentParameters = {
         model: 'qwen-turbo',
         contents: [{ role: 'user', parts: [{ text: 'Hello' }] }],
@@ -261,12 +380,62 @@ describe('QwenContentGenerator', () => {
       expect(mockQwenClient.refreshAccessToken).toHaveBeenCalled();
     });
 
-    it('should handle token refresh failure', async () => {
-      vi.mocked(mockQwenClient.getAccessToken).mockRejectedValue(
-        new Error('Token expired'),
+    it('should refresh token on auth error and retry for content stream', async () => {
+      const authError = { status: 401, message: 'Unauthorized' };
+
+      // Reset mocks for this test
+      vi.clearAllMocks();
+
+      // First call fails with auth error, second call succeeds
+      vi.mocked(mockQwenClient.getAccessToken)
+        .mockRejectedValueOnce(authError)
+        .mockResolvedValueOnce({ token: 'refreshed-stream-token' });
+
+      // Refresh succeeds
+      vi.mocked(mockQwenClient.refreshAccessToken).mockResolvedValue({
+        access_token: 'refreshed-stream-token',
+        token_type: 'Bearer',
+        expires_in: 3600,
+        resource_url: 'https://refreshed-stream-endpoint.com',
+      });
+
+      // Set credentials for second call
+      vi.mocked(mockQwenClient.getCredentials).mockReturnValue({
+        access_token: 'refreshed-stream-token',
+        token_type: 'Bearer',
+        refresh_token: 'refresh-token',
+        resource_url: 'https://refreshed-stream-endpoint.com',
+        expiry_date: Date.now() + 3600000,
+      });
+
+      const request: GenerateContentParameters = {
+        model: 'qwen-turbo',
+        contents: [{ role: 'user', parts: [{ text: 'Hello stream' }] }],
+      };
+
+      const stream = await qwenContentGenerator.generateContentStream(
+        request,
+        'test-prompt-id',
       );
-      vi.mocked(mockQwenClient.refreshAccessToken).mockRejectedValue(
-        new Error('Refresh failed'),
+      const chunks: string[] = [];
+
+      for await (const chunk of stream) {
+        chunks.push(chunk.text || '');
+      }
+
+      expect(chunks).toEqual(['Stream chunk 1', 'Stream chunk 2']);
+      expect(mockQwenClient.refreshAccessToken).toHaveBeenCalled();
+    });
+
+    it('should handle token refresh failure', async () => {
+      // Mock the SharedTokenManager to throw an error
+      const mockTokenManager = SharedTokenManager.getInstance() as unknown as {
+        setMockError: (error: Error | null) => void;
+      };
+      mockTokenManager.setMockError(
+        new Error(
+          'Failed to obtain valid Qwen access token. Please re-authenticate.',
+        ),
       );
 
       const request: GenerateContentParameters = {
@@ -279,6 +448,9 @@ describe('QwenContentGenerator', () => {
       ).rejects.toThrow(
         'Failed to obtain valid Qwen access token. Please re-authenticate.',
       );
+
+      // Clean up
+      mockTokenManager.setMockError(null);
     });
 
     it('should update endpoint when token is refreshed', async () => {
@@ -547,10 +719,24 @@ describe('QwenContentGenerator', () => {
       const originalGenerateContent = parentPrototype.generateContent;
       parentPrototype.generateContent = mockGenerateContent;
 
-      vi.mocked(mockQwenClient.getAccessToken).mockResolvedValue({
-        token: 'initial-token',
+      // Mock getAccessToken to fail initially, then succeed
+      let getAccessTokenCallCount = 0;
+      vi.mocked(mockQwenClient.getAccessToken).mockImplementation(async () => {
+        getAccessTokenCallCount++;
+        if (getAccessTokenCallCount <= 2) {
+          throw authError; // Fail on first two calls (initial + retry)
+        }
+        return { token: 'refreshed-token' }; // Succeed after refresh
       });
-      vi.mocked(mockQwenClient.getCredentials).mockReturnValue(mockCredentials);
+
+      vi.mocked(mockQwenClient.getCredentials).mockReturnValue({
+        access_token: 'refreshed-token',
+        token_type: 'Bearer',
+        refresh_token: 'refresh-token',
+        resource_url: 'https://test-endpoint.com',
+        expiry_date: Date.now() + 3600000,
+      });
+
       vi.mocked(mockQwenClient.refreshAccessToken).mockResolvedValue({
         access_token: 'refreshed-token',
         token_type: 'Bearer',
@@ -637,31 +823,16 @@ describe('QwenContentGenerator', () => {
       expect(qwenContentGenerator.getCurrentToken()).toBe('cached-token');
     });
 
-    it('should clear token and endpoint on clearToken()', () => {
-      // Simulate having cached values
+    it('should clear token on clearToken()', () => {
+      // Simulate having cached token value
       const qwenInstance = qwenContentGenerator as unknown as {
         currentToken: string;
-        currentEndpoint: string;
-        refreshPromise: Promise<string>;
       };
       qwenInstance.currentToken = 'cached-token';
-      qwenInstance.currentEndpoint = 'https://cached-endpoint.com';
-      qwenInstance.refreshPromise = Promise.resolve('token');
 
       qwenContentGenerator.clearToken();
 
       expect(qwenContentGenerator.getCurrentToken()).toBeNull();
-      expect(
-        (qwenContentGenerator as unknown as { currentEndpoint: string | null })
-          .currentEndpoint,
-      ).toBeNull();
-      expect(
-        (
-          qwenContentGenerator as unknown as {
-            refreshPromise: Promise<string> | null;
-          }
-        ).refreshPromise,
-      ).toBeNull();
     });
 
     it('should handle concurrent token refresh requests', async () => {
@@ -674,9 +845,7 @@ describe('QwenContentGenerator', () => {
       const authError = { status: 401, message: 'Unauthorized' };
       let parentCallCount = 0;
 
-      vi.mocked(mockQwenClient.getAccessToken).mockResolvedValue({
-        token: 'initial-token',
-      });
+      vi.mocked(mockQwenClient.getAccessToken).mockRejectedValue(authError);
       vi.mocked(mockQwenClient.getCredentials).mockReturnValue(mockCredentials);
 
       vi.mocked(mockQwenClient.refreshAccessToken).mockImplementation(
@@ -725,6 +894,7 @@ describe('QwenContentGenerator', () => {
 
       // The main test is that all requests succeed without crashing
       expect(results).toHaveLength(3);
+      // With our new implementation through SharedTokenManager, refresh should still be called
       expect(refreshCallCount).toBeGreaterThanOrEqual(1);
 
       // Restore original method
@@ -796,13 +966,24 @@ describe('QwenContentGenerator', () => {
       );
       parentPrototype.generateContent = mockGenerateContent;
 
-      vi.mocked(mockQwenClient.getAccessToken).mockResolvedValue({
-        token: 'initial-token',
+      // Mock getAccessToken to fail initially, then succeed
+      let getAccessTokenCallCount = 0;
+      vi.mocked(mockQwenClient.getAccessToken).mockImplementation(async () => {
+        getAccessTokenCallCount++;
+        if (getAccessTokenCallCount <= 2) {
+          throw authError; // Fail on first two calls (initial + retry)
+        }
+        return { token: 'new-token' }; // Succeed after refresh
       });
+
       vi.mocked(mockQwenClient.getCredentials).mockReturnValue({
-        ...mockCredentials,
-        resource_url: 'custom-endpoint.com',
+        access_token: 'new-token',
+        token_type: 'Bearer',
+        refresh_token: 'refresh-token',
+        resource_url: 'https://new-endpoint.com',
+        expiry_date: Date.now() + 7200000,
       });
+
       vi.mocked(mockQwenClient.refreshAccessToken).mockResolvedValue({
         access_token: 'new-token',
         token_type: 'Bearer',
@@ -826,4 +1007,595 @@ describe('QwenContentGenerator', () => {
       expect(callCount).toBe(2); // Initial call + retry
     });
   });
+
+  describe('SharedTokenManager Integration', () => {
+    it('should use SharedTokenManager to get valid credentials', async () => {
+      const mockTokenManager = {
+        getValidCredentials: vi.fn().mockResolvedValue({
+          access_token: 'manager-token',
+          resource_url: 'https://manager-endpoint.com',
+        }),
+        getCurrentCredentials: vi.fn(),
+        clearCache: vi.fn(),
+      };
+
+      // Mock the SharedTokenManager.getInstance()
+      const originalGetInstance = SharedTokenManager.getInstance;
+      SharedTokenManager.getInstance = vi
+        .fn()
+        .mockReturnValue(mockTokenManager);
+
+      // Create new instance to pick up the mock
+      const newGenerator = new QwenContentGenerator(
+        mockQwenClient,
+        { model: 'qwen-turbo', authType: AuthType.QWEN_OAUTH },
+        mockConfig,
+      );
+
+      const request: GenerateContentParameters = {
+        model: 'qwen-turbo',
+        contents: [{ role: 'user', parts: [{ text: 'Hello' }] }],
+      };
+
+      await newGenerator.generateContent(request, 'test-prompt-id');
+
+      expect(mockTokenManager.getValidCredentials).toHaveBeenCalledWith(
+        mockQwenClient,
+      );
+
+      // Restore original
+      SharedTokenManager.getInstance = originalGetInstance;
+    });
+
+    it('should handle SharedTokenManager errors gracefully', async () => {
+      const mockTokenManager = {
+        getValidCredentials: vi
+          .fn()
+          .mockRejectedValue(new Error('Token manager error')),
+        getCurrentCredentials: vi.fn(),
+        clearCache: vi.fn(),
+      };
+
+      const originalGetInstance = SharedTokenManager.getInstance;
+      SharedTokenManager.getInstance = vi
+        .fn()
+        .mockReturnValue(mockTokenManager);
+
+      const newGenerator = new QwenContentGenerator(
+        mockQwenClient,
+        { model: 'qwen-turbo', authType: AuthType.QWEN_OAUTH },
+        mockConfig,
+      );
+
+      const request: GenerateContentParameters = {
+        model: 'qwen-turbo',
+        contents: [{ role: 'user', parts: [{ text: 'Hello' }] }],
+      };
+
+      await expect(
+        newGenerator.generateContent(request, 'test-prompt-id'),
+      ).rejects.toThrow('Failed to obtain valid Qwen access token');
+
+      SharedTokenManager.getInstance = originalGetInstance;
+    });
+
+    it('should handle missing access token from credentials', async () => {
+      const mockTokenManager = {
+        getValidCredentials: vi.fn().mockResolvedValue({
+          access_token: undefined,
+          resource_url: 'https://test-endpoint.com',
+        }),
+        getCurrentCredentials: vi.fn(),
+        clearCache: vi.fn(),
+      };
+
+      const originalGetInstance = SharedTokenManager.getInstance;
+      SharedTokenManager.getInstance = vi
+        .fn()
+        .mockReturnValue(mockTokenManager);
+
+      const newGenerator = new QwenContentGenerator(
+        mockQwenClient,
+        { model: 'qwen-turbo', authType: AuthType.QWEN_OAUTH },
+        mockConfig,
+      );
+
+      const request: GenerateContentParameters = {
+        model: 'qwen-turbo',
+        contents: [{ role: 'user', parts: [{ text: 'Hello' }] }],
+      };
+
+      await expect(
+        newGenerator.generateContent(request, 'test-prompt-id'),
+      ).rejects.toThrow('Failed to obtain valid Qwen access token');
+
+      SharedTokenManager.getInstance = originalGetInstance;
+    });
+  });
+
+  describe('getCurrentEndpoint Method', () => {
+    it('should handle URLs with custom ports', () => {
+      const endpoints = [
+        { input: 'localhost:8080', expected: 'https://localhost:8080/v1' },
+        {
+          input: 'http://localhost:8080',
+          expected: 'http://localhost:8080/v1',
+        },
+        {
+          input: 'https://api.example.com:443',
+          expected: 'https://api.example.com:443/v1',
+        },
+        {
+          input: 'api.example.com:9000/api',
+          expected: 'https://api.example.com:9000/api/v1',
+        },
+      ];
+
+      endpoints.forEach(({ input, expected }) => {
+        vi.mocked(mockQwenClient.getAccessToken).mockResolvedValue({
+          token: 'test-token',
+        });
+        vi.mocked(mockQwenClient.getCredentials).mockReturnValue({
+          ...mockCredentials,
+          resource_url: input,
+        });
+
+        const generator = qwenContentGenerator as unknown as {
+          getCurrentEndpoint: (resourceUrl?: string) => string;
+        };
+
+        expect(generator.getCurrentEndpoint(input)).toBe(expected);
+      });
+    });
+
+    it('should handle URLs with existing paths', () => {
+      const endpoints = [
+        {
+          input: 'https://api.example.com/api',
+          expected: 'https://api.example.com/api/v1',
+        },
+        {
+          input: 'api.example.com/api/v2',
+          expected: 'https://api.example.com/api/v2/v1',
+        },
+        {
+          input: 'https://api.example.com/api/v1',
+          expected: 'https://api.example.com/api/v1',
+        },
+      ];
+
+      endpoints.forEach(({ input, expected }) => {
+        const generator = qwenContentGenerator as unknown as {
+          getCurrentEndpoint: (resourceUrl?: string) => string;
+        };
+
+        expect(generator.getCurrentEndpoint(input)).toBe(expected);
+      });
+    });
+
+    it('should handle undefined resource URL', () => {
+      const generator = qwenContentGenerator as unknown as {
+        getCurrentEndpoint: (resourceUrl?: string) => string;
+      };
+
+      expect(generator.getCurrentEndpoint(undefined)).toBe(
+        'https://dashscope.aliyuncs.com/compatible-mode/v1',
+      );
+    });
+
+    it('should handle empty resource URL', () => {
+      const generator = qwenContentGenerator as unknown as {
+        getCurrentEndpoint: (resourceUrl?: string) => string;
+      };
+
+      // Empty string should fall back to default endpoint
+      expect(generator.getCurrentEndpoint('')).toBe(
+        'https://dashscope.aliyuncs.com/compatible-mode/v1',
+      );
+    });
+  });
+
+  describe('isAuthError Method Enhanced', () => {
+    it('should identify auth errors by numeric status codes', () => {
+      const authErrors = [
+        { code: 401 },
+        { status: 403 },
+        { code: '401' }, // String status codes
+        { status: '403' },
+      ];
+
+      authErrors.forEach((error) => {
+        const generator = qwenContentGenerator as unknown as {
+          isAuthError: (error: unknown) => boolean;
+        };
+        expect(generator.isAuthError(error)).toBe(true);
+      });
+
+      // 400 is not typically an auth error, it's bad request
+      const nonAuthError = { status: 400 };
+      const generator = qwenContentGenerator as unknown as {
+        isAuthError: (error: unknown) => boolean;
+      };
+      expect(generator.isAuthError(nonAuthError)).toBe(false);
+    });
+
+    it('should identify auth errors by message content variations', () => {
+      const authMessages = [
+        'UNAUTHORIZED access',
+        'Access is FORBIDDEN',
+        'Invalid API Key provided',
+        'Invalid Access Token',
+        'Token has Expired',
+        'Authentication Required',
+        'Access Denied by server',
+        'The token has expired and needs refresh',
+        'Bearer token expired',
+      ];
+
+      authMessages.forEach((message) => {
+        const error = new Error(message);
+        const generator = qwenContentGenerator as unknown as {
+          isAuthError: (error: unknown) => boolean;
+        };
+        expect(generator.isAuthError(error)).toBe(true);
+      });
+    });
+
+    it('should not identify non-auth errors', () => {
+      const nonAuthErrors = [
+        new Error('Network timeout'),
+        new Error('Rate limit exceeded'),
+        { status: 500 },
+        { code: 429 },
+        'Internal server error',
+        null,
+        undefined,
+        '',
+        { status: 200 },
+        new Error('Model not found'),
+      ];
+
+      nonAuthErrors.forEach((error) => {
+        const generator = qwenContentGenerator as unknown as {
+          isAuthError: (error: unknown) => boolean;
+        };
+        expect(generator.isAuthError(error)).toBe(false);
+      });
+    });
+
+    it('should handle complex error objects', () => {
+      const complexErrors = [
+        { error: { status: 401, message: 'Unauthorized' } },
+        { response: { status: 403 } },
+        { details: { code: 401 } },
+      ];
+
+      // These should not be identified as auth errors because the method only looks at top-level properties
+      complexErrors.forEach((error) => {
+        const generator = qwenContentGenerator as unknown as {
+          isAuthError: (error: unknown) => boolean;
+        };
+        expect(generator.isAuthError(error)).toBe(false);
+      });
+    });
+  });
+
+  describe('Stream Error Handling', () => {
+    it('should restore credentials when stream generation fails', async () => {
+      const client = (
+        qwenContentGenerator as unknown as {
+          client: { apiKey: string; baseURL: string };
+        }
+      ).client;
+      const originalApiKey = client.apiKey;
+      const originalBaseURL = client.baseURL;
+
+      vi.mocked(mockQwenClient.getAccessToken).mockResolvedValue({
+        token: 'stream-token',
+      });
+      vi.mocked(mockQwenClient.getCredentials).mockReturnValue({
+        ...mockCredentials,
+        resource_url: 'https://stream-endpoint.com',
+      });
+
+      // Mock parent method to throw error
+      const parentPrototype = Object.getPrototypeOf(
+        Object.getPrototypeOf(qwenContentGenerator),
+      );
+      const originalGenerateContentStream =
+        parentPrototype.generateContentStream;
+      parentPrototype.generateContentStream = vi
+        .fn()
+        .mockRejectedValue(new Error('Stream error'));
+
+      const request: GenerateContentParameters = {
+        model: 'qwen-turbo',
+        contents: [{ role: 'user', parts: [{ text: 'Stream test' }] }],
+      };
+
+      try {
+        await qwenContentGenerator.generateContentStream(
+          request,
+          'test-prompt-id',
+        );
+      } catch (error) {
+        expect(error).toBeInstanceOf(Error);
+      }
+
+      // Credentials should be restored even on error
+      expect(client.apiKey).toBe(originalApiKey);
+      expect(client.baseURL).toBe(originalBaseURL);
+
+      // Restore original method
+      parentPrototype.generateContentStream = originalGenerateContentStream;
+    });
+
+    it('should not restore credentials in finally block for successful streams', async () => {
+      const client = (
+        qwenContentGenerator as unknown as {
+          client: { apiKey: string; baseURL: string };
+        }
+      ).client;
+
+      // Set up the mock to return stream credentials
+      const streamCredentials = {
+        access_token: 'stream-token',
+        refresh_token: 'stream-refresh-token',
+        resource_url: 'https://stream-endpoint.com',
+        expiry_date: Date.now() + 3600000,
+      };
+
+      vi.mocked(mockQwenClient.getAccessToken).mockResolvedValue({
+        token: 'stream-token',
+      });
+      vi.mocked(mockQwenClient.getCredentials).mockReturnValue(
+        streamCredentials,
+      );
+
+      // Set the SharedTokenManager mock to return stream credentials
+      const mockTokenManager = SharedTokenManager.getInstance() as unknown as {
+        setMockCredentials: (credentials: QwenCredentials | null) => void;
+      };
+      mockTokenManager.setMockCredentials(streamCredentials);
+
+      const request: GenerateContentParameters = {
+        model: 'qwen-turbo',
+        contents: [{ role: 'user', parts: [{ text: 'Stream test' }] }],
+      };
+
+      const stream = await qwenContentGenerator.generateContentStream(
+        request,
+        'test-prompt-id',
+      );
+
+      // After successful stream creation, credentials should still be set for the stream
+      expect(client.apiKey).toBe('stream-token');
+      expect(client.baseURL).toBe('https://stream-endpoint.com/v1');
+
+      // Consume the stream
+      const chunks = [];
+      for await (const chunk of stream) {
+        chunks.push(chunk);
+      }
+
+      expect(chunks).toHaveLength(2);
+
+      // Clean up
+      mockTokenManager.setMockCredentials(null);
+    });
+  });
+
+  describe('Token and Endpoint Management', () => {
+    it('should get current token from SharedTokenManager', () => {
+      const mockTokenManager = {
+        getCurrentCredentials: vi.fn().mockReturnValue({
+          access_token: 'current-token',
+        }),
+      };
+
+      const originalGetInstance = SharedTokenManager.getInstance;
+      SharedTokenManager.getInstance = vi
+        .fn()
+        .mockReturnValue(mockTokenManager);
+
+      const newGenerator = new QwenContentGenerator(
+        mockQwenClient,
+        { model: 'qwen-turbo', authType: AuthType.QWEN_OAUTH },
+        mockConfig,
+      );
+
+      expect(newGenerator.getCurrentToken()).toBe('current-token');
+
+      SharedTokenManager.getInstance = originalGetInstance;
+    });
+
+    it('should return null when no credentials available', () => {
+      const mockTokenManager = {
+        getCurrentCredentials: vi.fn().mockReturnValue(null),
+      };
+
+      const originalGetInstance = SharedTokenManager.getInstance;
+      SharedTokenManager.getInstance = vi
+        .fn()
+        .mockReturnValue(mockTokenManager);
+
+      const newGenerator = new QwenContentGenerator(
+        mockQwenClient,
+        { model: 'qwen-turbo', authType: AuthType.QWEN_OAUTH },
+        mockConfig,
+      );
+
+      expect(newGenerator.getCurrentToken()).toBeNull();
+
+      SharedTokenManager.getInstance = originalGetInstance;
+    });
+
+    it('should return null when credentials have no access token', () => {
+      const mockTokenManager = {
+        getCurrentCredentials: vi.fn().mockReturnValue({
+          access_token: undefined,
+        }),
+      };
+
+      const originalGetInstance = SharedTokenManager.getInstance;
+      SharedTokenManager.getInstance = vi
+        .fn()
+        .mockReturnValue(mockTokenManager);
+
+      const newGenerator = new QwenContentGenerator(
+        mockQwenClient,
+        { model: 'qwen-turbo', authType: AuthType.QWEN_OAUTH },
+        mockConfig,
+      );
+
+      expect(newGenerator.getCurrentToken()).toBeNull();
+
+      SharedTokenManager.getInstance = originalGetInstance;
+    });
+
+    it('should clear token through SharedTokenManager', () => {
+      const mockTokenManager = {
+        clearCache: vi.fn(),
+      };
+
+      const originalGetInstance = SharedTokenManager.getInstance;
+      SharedTokenManager.getInstance = vi
+        .fn()
+        .mockReturnValue(mockTokenManager);
+
+      const newGenerator = new QwenContentGenerator(
+        mockQwenClient,
+        { model: 'qwen-turbo', authType: AuthType.QWEN_OAUTH },
+        mockConfig,
+      );
+
+      newGenerator.clearToken();
+
+      expect(mockTokenManager.clearCache).toHaveBeenCalled();
+
+      SharedTokenManager.getInstance = originalGetInstance;
+    });
+  });
+
+  describe('Constructor and Initialization', () => {
+    it('should initialize with default base URL', () => {
+      const generator = new QwenContentGenerator(
+        mockQwenClient,
+        { model: 'qwen-turbo', authType: AuthType.QWEN_OAUTH },
+        mockConfig,
+      );
+
+      const client = (generator as unknown as { client: { baseURL: string } })
+        .client;
+      expect(client.baseURL).toBe(
+        'https://dashscope.aliyuncs.com/compatible-mode/v1',
+      );
+    });
+
+    it('should get SharedTokenManager instance', () => {
+      const generator = new QwenContentGenerator(
+        mockQwenClient,
+        { model: 'qwen-turbo', authType: AuthType.QWEN_OAUTH },
+        mockConfig,
+      );
+
+      const sharedManager = (
+        generator as unknown as { sharedManager: SharedTokenManager }
+      ).sharedManager;
+      expect(sharedManager).toBeDefined();
+    });
+  });
+
+  describe('Edge Cases and Error Conditions', () => {
+    it('should handle token retrieval with warning when SharedTokenManager fails', async () => {
+      const consoleSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+
+      const mockTokenManager = {
+        getValidCredentials: vi
+          .fn()
+          .mockRejectedValue(new Error('Internal token manager error')),
+      };
+
+      const originalGetInstance = SharedTokenManager.getInstance;
+      SharedTokenManager.getInstance = vi
+        .fn()
+        .mockReturnValue(mockTokenManager);
+
+      const newGenerator = new QwenContentGenerator(
+        mockQwenClient,
+        { model: 'qwen-turbo', authType: AuthType.QWEN_OAUTH },
+        mockConfig,
+      );
+
+      const request: GenerateContentParameters = {
+        model: 'qwen-turbo',
+        contents: [{ role: 'user', parts: [{ text: 'Hello' }] }],
+      };
+
+      await expect(
+        newGenerator.generateContent(request, 'test-prompt-id'),
+      ).rejects.toThrow('Failed to obtain valid Qwen access token');
+
+      expect(consoleSpy).toHaveBeenCalledWith(
+        'Failed to get token from shared manager:',
+        expect.any(Error),
+      );
+
+      consoleSpy.mockRestore();
+      SharedTokenManager.getInstance = originalGetInstance;
+    });
+
+    it('should handle all method types with token failure', async () => {
+      const mockTokenManager = {
+        getValidCredentials: vi
+          .fn()
+          .mockRejectedValue(new Error('Token error')),
+      };
+
+      const originalGetInstance = SharedTokenManager.getInstance;
+      SharedTokenManager.getInstance = vi
+        .fn()
+        .mockReturnValue(mockTokenManager);
+
+      const newGenerator = new QwenContentGenerator(
+        mockQwenClient,
+        { model: 'qwen-turbo', authType: AuthType.QWEN_OAUTH },
+        mockConfig,
+      );
+
+      const generateRequest: GenerateContentParameters = {
+        model: 'qwen-turbo',
+        contents: [{ role: 'user', parts: [{ text: 'Hello' }] }],
+      };
+
+      const countRequest: CountTokensParameters = {
+        model: 'qwen-turbo',
+        contents: [{ role: 'user', parts: [{ text: 'Count' }] }],
+      };
+
+      const embedRequest: EmbedContentParameters = {
+        model: 'qwen-turbo',
+        contents: [{ parts: [{ text: 'Embed' }] }],
+      };
+
+      // All methods should fail with the same error
+      await expect(
+        newGenerator.generateContent(generateRequest, 'test-id'),
+      ).rejects.toThrow('Failed to obtain valid Qwen access token');
+
+      await expect(
+        newGenerator.generateContentStream(generateRequest, 'test-id'),
+      ).rejects.toThrow('Failed to obtain valid Qwen access token');
+
+      await expect(newGenerator.countTokens(countRequest)).rejects.toThrow(
+        'Failed to obtain valid Qwen access token',
+      );
+
+      await expect(newGenerator.embedContent(embedRequest)).rejects.toThrow(
+        'Failed to obtain valid Qwen access token',
+      );
+
+      SharedTokenManager.getInstance = originalGetInstance;
+    });
+  });
 });