Add files using upload-large-folder tool

projects/ui/qwen-code/packages/core/src/ide/ide-client.test.ts

@@ -0,0 +1,78 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { describe, it, expect } from 'vitest';
+import * as path from 'path';
+import { IdeClient } from './ide-client.js';
+
+describe('IdeClient.validateWorkspacePath', () => {
+  it('should return valid if cwd is a subpath of the IDE workspace path', () => {
+    const result = IdeClient.validateWorkspacePath(
+      '/Users/person/gemini-cli',
+      'VS Code',
+      '/Users/person/gemini-cli/sub-dir',
+    );
+    expect(result.isValid).toBe(true);
+  });
+
+  it('should return invalid if GEMINI_CLI_IDE_WORKSPACE_PATH is undefined', () => {
+    const result = IdeClient.validateWorkspacePath(
+      undefined,
+      'VS Code',
+      '/Users/person/gemini-cli/sub-dir',
+    );
+    expect(result.isValid).toBe(false);
+    expect(result.error).toContain('Failed to connect');
+  });
+
+  it('should return invalid if GEMINI_CLI_IDE_WORKSPACE_PATH is empty', () => {
+    const result = IdeClient.validateWorkspacePath(
+      '',
+      'VS Code',
+      '/Users/person/gemini-cli/sub-dir',
+    );
+    expect(result.isValid).toBe(false);
+    expect(result.error).toContain('please open a workspace folder');
+  });
+
+  it('should return invalid if cwd is not within the IDE workspace path', () => {
+    const result = IdeClient.validateWorkspacePath(
+      '/some/other/path',
+      'VS Code',
+      '/Users/person/gemini-cli/sub-dir',
+    );
+    expect(result.isValid).toBe(false);
+    expect(result.error).toContain('Directory mismatch');
+  });
+
+  it('should handle multiple workspace paths and return valid', () => {
+    const result = IdeClient.validateWorkspacePath(
+      ['/some/other/path', '/Users/person/gemini-cli'].join(path.delimiter),
+      'VS Code',
+      '/Users/person/gemini-cli/sub-dir',
+    );
+    expect(result.isValid).toBe(true);
+  });
+
+  it('should return invalid if cwd is not in any of the multiple workspace paths', () => {
+    const result = IdeClient.validateWorkspacePath(
+      ['/some/other/path', '/another/path'].join(path.delimiter),
+      'VS Code',
+      '/Users/person/gemini-cli/sub-dir',
+    );
+    expect(result.isValid).toBe(false);
+    expect(result.error).toContain('Directory mismatch');
+  });
+
+  it.skipIf(process.platform !== 'win32')('should handle windows paths', () => {
+    const result = IdeClient.validateWorkspacePath(
+      'c:/some/other/path;d:/Users/person/gemini-cli',
+      'VS Code',
+      'd:/Users/person/gemini-cli/sub-dir',
+    );
+    expect(result.isValid).toBe(true);
+  });
+});

projects/ui/qwen-code/packages/core/src/ide/ide-client.ts

@@ -0,0 +1,456 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import * as fs from 'node:fs';
+import { isSubpath } from '../utils/paths.js';
+import { detectIde, DetectedIde, getIdeInfo } from '../ide/detect-ide.js';
+import {
+  ideContext,
+  IdeContextNotificationSchema,
+  IdeDiffAcceptedNotificationSchema,
+  IdeDiffClosedNotificationSchema,
+  CloseDiffResponseSchema,
+  DiffUpdateResult,
+} from '../ide/ideContext.js';
+import { getIdeProcessId } from './process-utils.js';
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { EnvHttpProxyAgent } from 'undici';
+
+const logger = {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  debug: (...args: any[]) => console.debug('[DEBUG] [IDEClient]', ...args),
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  error: (...args: any[]) => console.error('[ERROR] [IDEClient]', ...args),
+};
+
+export type IDEConnectionState = {
+  status: IDEConnectionStatus;
+  details?: string; // User-facing
+};
+
+export enum IDEConnectionStatus {
+  Connected = 'connected',
+  Disconnected = 'disconnected',
+  Connecting = 'connecting',
+}
+
+function getRealPath(path: string): string {
+  try {
+    return fs.realpathSync(path);
+  } catch (_e) {
+    // If realpathSync fails, it might be because the path doesn't exist.
+    // In that case, we can fall back to the original path.
+    return path;
+  }
+}
+
+/**
+ * Manages the connection to and interaction with the IDE server.
+ */
+export class IdeClient {
+  private static instance: IdeClient;
+  private client: Client | undefined = undefined;
+  private state: IDEConnectionState = {
+    status: IDEConnectionStatus.Disconnected,
+    details:
+      'IDE integration is currently disabled. To enable it, run /ide enable.',
+  };
+  private readonly currentIde: DetectedIde | undefined;
+  private readonly currentIdeDisplayName: string | undefined;
+  private diffResponses = new Map<string, (result: DiffUpdateResult) => void>();
+  private statusListeners = new Set<(state: IDEConnectionState) => void>();
+
+  private constructor() {
+    this.currentIde = detectIde();
+    if (this.currentIde) {
+      this.currentIdeDisplayName = getIdeInfo(this.currentIde).displayName;
+    }
+  }
+
+  static getInstance(): IdeClient {
+    if (!IdeClient.instance) {
+      IdeClient.instance = new IdeClient();
+    }
+    return IdeClient.instance;
+  }
+
+  addStatusChangeListener(listener: (state: IDEConnectionState) => void) {
+    this.statusListeners.add(listener);
+  }
+
+  removeStatusChangeListener(listener: (state: IDEConnectionState) => void) {
+    this.statusListeners.delete(listener);
+  }
+
+  async connect(): Promise<void> {
+    if (!this.currentIde || !this.currentIdeDisplayName) {
+      this.setState(
+        IDEConnectionStatus.Disconnected,
+        `IDE integration is not supported in your current environment. To use this feature, run Qwen Code in one of these supported IDEs: ${Object.values(
+          DetectedIde,
+        )
+          .map((ide) => getIdeInfo(ide).displayName)
+          .join(', ')}`,
+        false,
+      );
+      return;
+    }
+
+    this.setState(IDEConnectionStatus.Connecting);
+
+    const ideInfoFromFile = await this.getIdeInfoFromFile();
+    const workspacePath =
+      ideInfoFromFile.workspacePath ??
+      process.env['QWEN_CODE_IDE_WORKSPACE_PATH'];
+
+    const { isValid, error } = IdeClient.validateWorkspacePath(
+      workspacePath,
+      this.currentIdeDisplayName,
+      process.cwd(),
+    );
+
+    if (!isValid) {
+      this.setState(IDEConnectionStatus.Disconnected, error, true);
+      return;
+    }
+
+    const portFromFile = ideInfoFromFile.port;
+    if (portFromFile) {
+      const connected = await this.establishConnection(portFromFile);
+      if (connected) {
+        return;
+      }
+    }
+
+    const portFromEnv = this.getPortFromEnv();
+    if (portFromEnv) {
+      const connected = await this.establishConnection(portFromEnv);
+      if (connected) {
+        return;
+      }
+    }
+
+    this.setState(
+      IDEConnectionStatus.Disconnected,
+      `Failed to connect to IDE companion extension for ${this.currentIdeDisplayName}. Please ensure the extension is running. To install the extension, run /ide install.`,
+      true,
+    );
+  }
+
+  /**
+   * A diff is accepted with any modifications if the user performs one of the
+   * following actions:
+   * - Clicks the checkbox icon in the IDE to accept
+   * - Runs `command+shift+p` > "Gemini CLI: Accept Diff in IDE" to accept
+   * - Selects "accept" in the CLI UI
+   * - Saves the file via `ctrl/command+s`
+   *
+   * A diff is rejected if the user performs one of the following actions:
+   * - Clicks the "x" icon in the IDE
+   * - Runs "Gemini CLI: Close Diff in IDE"
+   * - Selects "no" in the CLI UI
+   * - Closes the file
+   */
+  async openDiff(
+    filePath: string,
+    newContent?: string,
+  ): Promise<DiffUpdateResult> {
+    return new Promise<DiffUpdateResult>((resolve, reject) => {
+      this.diffResponses.set(filePath, resolve);
+      this.client
+        ?.callTool({
+          name: `openDiff`,
+          arguments: {
+            filePath,
+            newContent,
+          },
+        })
+        .catch((err) => {
+          logger.debug(`callTool for ${filePath} failed:`, err);
+          reject(err);
+        });
+    });
+  }
+
+  async closeDiff(filePath: string): Promise<string | undefined> {
+    try {
+      const result = await this.client?.callTool({
+        name: `closeDiff`,
+        arguments: {
+          filePath,
+        },
+      });
+
+      if (result) {
+        const parsed = CloseDiffResponseSchema.parse(result);
+        return parsed.content;
+      }
+    } catch (err) {
+      logger.debug(`callTool for ${filePath} failed:`, err);
+    }
+    return;
+  }
+
+  // Closes the diff. Instead of waiting for a notification,
+  // manually resolves the diff resolver as the desired outcome.
+  async resolveDiffFromCli(filePath: string, outcome: 'accepted' | 'rejected') {
+    const content = await this.closeDiff(filePath);
+    const resolver = this.diffResponses.get(filePath);
+    if (resolver) {
+      if (outcome === 'accepted') {
+        resolver({ status: 'accepted', content });
+      } else {
+        resolver({ status: 'rejected', content: undefined });
+      }
+      this.diffResponses.delete(filePath);
+    }
+  }
+
+  async disconnect() {
+    if (this.state.status === IDEConnectionStatus.Disconnected) {
+      return;
+    }
+    for (const filePath of this.diffResponses.keys()) {
+      await this.closeDiff(filePath);
+    }
+    this.diffResponses.clear();
+    this.setState(
+      IDEConnectionStatus.Disconnected,
+      'IDE integration disabled. To enable it again, run /ide enable.',
+    );
+    this.client?.close();
+  }
+
+  getCurrentIde(): DetectedIde | undefined {
+    return this.currentIde;
+  }
+
+  getConnectionStatus(): IDEConnectionState {
+    return this.state;
+  }
+
+  getDetectedIdeDisplayName(): string | undefined {
+    return this.currentIdeDisplayName;
+  }
+
+  private setState(
+    status: IDEConnectionStatus,
+    details?: string,
+    logToConsole = false,
+  ) {
+    const isAlreadyDisconnected =
+      this.state.status === IDEConnectionStatus.Disconnected &&
+      status === IDEConnectionStatus.Disconnected;
+
+    // Only update details & log to console if the state wasn't already
+    // disconnected, so that the first detail message is preserved.
+    if (!isAlreadyDisconnected) {
+      this.state = { status, details };
+      for (const listener of this.statusListeners) {
+        listener(this.state);
+      }
+      if (details) {
+        if (logToConsole) {
+          logger.error(details);
+        } else {
+          // We only want to log disconnect messages to debug
+          // if they are not already being logged to the console.
+          logger.debug(details);
+        }
+      }
+    }
+
+    if (status === IDEConnectionStatus.Disconnected) {
+      ideContext.clearIdeContext();
+    }
+  }
+
+  static validateWorkspacePath(
+    ideWorkspacePath: string | undefined,
+    currentIdeDisplayName: string | undefined,
+    cwd: string,
+  ): { isValid: boolean; error?: string } {
+    if (ideWorkspacePath === undefined) {
+      return {
+        isValid: false,
+        error: `Failed to connect to IDE companion extension for ${currentIdeDisplayName}. Please ensure the extension is running. To install the extension, run /ide install.`,
+      };
+    }
+
+    if (ideWorkspacePath === '') {
+      return {
+        isValid: false,
+        error: `To use this feature, please open a workspace folder in ${currentIdeDisplayName} and try again.`,
+      };
+    }
+
+    const ideWorkspacePaths = ideWorkspacePath.split(path.delimiter);
+    const realCwd = getRealPath(cwd);
+    const isWithinWorkspace = ideWorkspacePaths.some((workspacePath) => {
+      const idePath = getRealPath(workspacePath);
+      return isSubpath(idePath, realCwd);
+    });
+
+    if (!isWithinWorkspace) {
+      return {
+        isValid: false,
+        error: `Directory mismatch. Qwen Code is running in a different location than the open workspace in ${currentIdeDisplayName}. Please run the CLI from one of the following directories: ${ideWorkspacePaths.join(
+          ', ',
+        )}`,
+      };
+    }
+    return { isValid: true };
+  }
+
+  private getPortFromEnv(): string | undefined {
+    const port = process.env['QWEN_CODE_IDE_SERVER_PORT'];
+    if (!port) {
+      return undefined;
+    }
+    return port;
+  }
+
+  private async getIdeInfoFromFile(): Promise<{
+    port?: string;
+    workspacePath?: string;
+  }> {
+    try {
+      const ideProcessId = await getIdeProcessId();
+      const portFile = path.join(
+        os.tmpdir(),
+        `qwen-code-ide-server-${ideProcessId}.json`,
+      );
+      const portFileContents = await fs.promises.readFile(portFile, 'utf8');
+      const ideInfo = JSON.parse(portFileContents);
+      return {
+        port: ideInfo?.port?.toString(),
+        workspacePath: ideInfo?.workspacePath,
+      };
+    } catch (_) {
+      return {};
+    }
+  }
+
+  private createProxyAwareFetch() {
+    // ignore proxy for 'localhost' by deafult to allow connecting to the ide mcp server
+    const existingNoProxy = process.env['NO_PROXY'] || '';
+    const agent = new EnvHttpProxyAgent({
+      noProxy: [existingNoProxy, 'localhost'].filter(Boolean).join(','),
+    });
+    const undiciPromise = import('undici');
+    return async (url: string | URL, init?: RequestInit): Promise<Response> => {
+      const { fetch: fetchFn } = await undiciPromise;
+      const fetchOptions: RequestInit & { dispatcher?: unknown } = {
+        ...init,
+        dispatcher: agent,
+      };
+      const options = fetchOptions as unknown as import('undici').RequestInit;
+      const response = await fetchFn(url, options);
+      return new Response(response.body as ReadableStream<unknown> | null, {
+        status: response.status,
+        statusText: response.statusText,
+        headers: response.headers,
+      });
+    };
+  }
+
+  private registerClientHandlers() {
+    if (!this.client) {
+      return;
+    }
+
+    this.client.setNotificationHandler(
+      IdeContextNotificationSchema,
+      (notification) => {
+        ideContext.setIdeContext(notification.params);
+      },
+    );
+    this.client.onerror = (_error) => {
+      this.setState(
+        IDEConnectionStatus.Disconnected,
+        `IDE connection error. The connection was lost unexpectedly. Please try reconnecting by running /ide enable`,
+        true,
+      );
+    };
+    this.client.onclose = () => {
+      this.setState(
+        IDEConnectionStatus.Disconnected,
+        `IDE connection error. The connection was lost unexpectedly. Please try reconnecting by running /ide enable`,
+        true,
+      );
+    };
+    this.client.setNotificationHandler(
+      IdeDiffAcceptedNotificationSchema,
+      (notification) => {
+        const { filePath, content } = notification.params;
+        const resolver = this.diffResponses.get(filePath);
+        if (resolver) {
+          resolver({ status: 'accepted', content });
+          this.diffResponses.delete(filePath);
+        } else {
+          logger.debug(`No resolver found for ${filePath}`);
+        }
+      },
+    );
+
+    this.client.setNotificationHandler(
+      IdeDiffClosedNotificationSchema,
+      (notification) => {
+        const { filePath } = notification.params;
+        const resolver = this.diffResponses.get(filePath);
+        if (resolver) {
+          resolver({ status: 'rejected', content: undefined });
+          this.diffResponses.delete(filePath);
+        } else {
+          logger.debug(`No resolver found for ${filePath}`);
+        }
+      },
+    );
+  }
+
+  private async establishConnection(port: string): Promise<boolean> {
+    let transport: StreamableHTTPClientTransport | undefined;
+    try {
+      this.client = new Client({
+        name: 'streamable-http-client',
+        // TODO(#3487): use the CLI version here.
+        version: '1.0.0',
+      });
+
+      transport = new StreamableHTTPClientTransport(
+        new URL(`http://${getIdeServerHost()}:${port}/mcp`),
+        {
+          fetch: this.createProxyAwareFetch(),
+        },
+      );
+
+      this.registerClientHandlers();
+
+      await this.client.connect(transport);
+      this.registerClientHandlers();
+      this.setState(IDEConnectionStatus.Connected);
+      return true;
+    } catch (_error) {
+      if (transport) {
+        try {
+          await transport.close();
+        } catch (closeError) {
+          logger.debug('Failed to close transport:', closeError);
+        }
+      }
+      return false;
+    }
+  }
+}
+
+function getIdeServerHost() {
+  const isInContainer =
+    fs.existsSync('/.dockerenv') || fs.existsSync('/run/.containerenv');
+  return isInContainer ? 'host.docker.internal' : 'localhost';
+}

projects/ui/qwen-code/packages/core/src/ide/ide-installer.test.ts

@@ -0,0 +1,65 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { vi, describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { getIdeInstaller, IdeInstaller } from './ide-installer.js';
+import * as child_process from 'child_process';
+import * as fs from 'fs';
+import * as os from 'os';
+import { DetectedIde } from './detect-ide.js';
+
+vi.mock('child_process');
+vi.mock('fs');
+vi.mock('os');
+
+describe('ide-installer', () => {
+  beforeEach(() => {
+    vi.spyOn(os, 'homedir').mockReturnValue('/home/user');
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  describe('getIdeInstaller', () => {
+    it('should return a VsCodeInstaller for "vscode"', () => {
+      const installer = getIdeInstaller(DetectedIde.VSCode);
+      expect(installer).not.toBeNull();
+      // A more specific check might be needed if we export the class
+      expect(installer).toBeInstanceOf(Object);
+    });
+
+    it('should return null for an unknown IDE', () => {
+      const installer = getIdeInstaller('unknown' as DetectedIde);
+      expect(installer).toBeNull();
+    });
+  });
+
+  describe('VsCodeInstaller', () => {
+    let installer: IdeInstaller;
+
+    beforeEach(() => {
+      // We get a new installer for each test to reset the find command logic
+      installer = getIdeInstaller(DetectedIde.VSCode)!;
+      vi.spyOn(child_process, 'execSync').mockImplementation(() => '');
+      vi.spyOn(fs, 'existsSync').mockReturnValue(false);
+    });
+
+    describe('install', () => {
+      it('should return a failure message if VS Code is not installed', async () => {
+        vi.spyOn(child_process, 'execSync').mockImplementation(() => {
+          throw new Error('Command not found');
+        });
+        vi.spyOn(fs, 'existsSync').mockReturnValue(false);
+        // Re-create the installer so it re-runs findVsCodeCommand
+        installer = getIdeInstaller(DetectedIde.VSCode)!;
+        const result = await installer.install();
+        expect(result.success).toBe(false);
+        expect(result.message).toContain('VS Code CLI not found');
+      });
+    });
+  });
+});

projects/ui/qwen-code/packages/core/src/ide/ide-installer.ts

@@ -0,0 +1,136 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import * as child_process from 'child_process';
+import * as process from 'process';
+import * as path from 'path';
+import * as fs from 'fs';
+import * as os from 'os';
+import { DetectedIde } from './detect-ide.js';
+import { QWEN_CODE_COMPANION_EXTENSION_NAME } from './constants.js';
+
+const VSCODE_COMMAND = process.platform === 'win32' ? 'code.cmd' : 'code';
+
+export interface IdeInstaller {
+  install(): Promise<InstallResult>;
+}
+
+export interface InstallResult {
+  success: boolean;
+  message: string;
+}
+
+async function findVsCodeCommand(): Promise<string | null> {
+  // 1. Check PATH first.
+  try {
+    if (process.platform === 'win32') {
+      const result = child_process
+        .execSync(`where.exe ${VSCODE_COMMAND}`)
+        .toString()
+        .trim();
+      // `where.exe` can return multiple paths. Return the first one.
+      const firstPath = result.split(/\r?\n/)[0];
+      if (firstPath) {
+        return firstPath;
+      }
+    } else {
+      child_process.execSync(`command -v ${VSCODE_COMMAND}`, {
+        stdio: 'ignore',
+      });
+      return VSCODE_COMMAND;
+    }
+  } catch {
+    // Not in PATH, continue to check common locations.
+  }
+
+  // 2. Check common installation locations.
+  const locations: string[] = [];
+  const platform = process.platform;
+  const homeDir = os.homedir();
+
+  if (platform === 'darwin') {
+    // macOS
+    locations.push(
+      '/Applications/Visual Studio Code.app/Contents/Resources/app/bin/code',
+      path.join(homeDir, 'Library/Application Support/Code/bin/code'),
+    );
+  } else if (platform === 'linux') {
+    // Linux
+    locations.push(
+      '/usr/share/code/bin/code',
+      '/snap/bin/code',
+      path.join(homeDir, '.local/share/code/bin/code'),
+    );
+  } else if (platform === 'win32') {
+    // Windows
+    locations.push(
+      path.join(
+        process.env['ProgramFiles'] || 'C:\\Program Files',
+        'Microsoft VS Code',
+        'bin',
+        'code.cmd',
+      ),
+      path.join(
+        homeDir,
+        'AppData',
+        'Local',
+        'Programs',
+        'Microsoft VS Code',
+        'bin',
+        'code.cmd',
+      ),
+    );
+  }
+
+  for (const location of locations) {
+    if (fs.existsSync(location)) {
+      return location;
+    }
+  }
+
+  return null;
+}
+
+class VsCodeInstaller implements IdeInstaller {
+  private vsCodeCommand: Promise<string | null>;
+
+  constructor() {
+    this.vsCodeCommand = findVsCodeCommand();
+  }
+
+  async install(): Promise<InstallResult> {
+    const commandPath = await this.vsCodeCommand;
+    if (!commandPath) {
+      return {
+        success: false,
+        message: `VS Code CLI not found. Please ensure 'code' is in your system's PATH. For help, see https://code.visualstudio.com/docs/configure/command-line#_code-is-not-recognized-as-an-internal-or-external-command. You can also install the '${QWEN_CODE_COMPANION_EXTENSION_NAME}' extension manually from the VS Code marketplace.`,
+      };
+    }
+
+    const command = `"${commandPath}" --install-extension qwenlm.qwen-code-vscode-ide-companion --force`;
+    try {
+      child_process.execSync(command, { stdio: 'pipe' });
+      return {
+        success: true,
+        message: 'VS Code companion extension was installed successfully.',
+      };
+    } catch (_error) {
+      return {
+        success: false,
+        message: `Failed to install VS Code companion extension. Please try installing '${QWEN_CODE_COMPANION_EXTENSION_NAME}' manually from the VS Code extension marketplace.`,
+      };
+    }
+  }
+}
+
+export function getIdeInstaller(ide: DetectedIde): IdeInstaller | null {
+  switch (ide) {
+    case DetectedIde.VSCode:
+      return new VsCodeInstaller();
+    default:
+      return null;
+  }
+}

projects/ui/qwen-code/packages/core/src/ide/ideContext.test.ts

@@ -0,0 +1,304 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import {
+  createIdeContextStore,
+  FileSchema,
+  IdeContextSchema,
+} from './ideContext.js';
+
+describe('ideContext', () => {
+  describe('createIdeContextStore', () => {
+    let ideContext: ReturnType<typeof createIdeContextStore>;
+
+    beforeEach(() => {
+      // Create a fresh, isolated instance for each test
+      ideContext = createIdeContextStore();
+    });
+
+    it('should return undefined initially for ide context', () => {
+      expect(ideContext.getIdeContext()).toBeUndefined();
+    });
+
+    it('should set and retrieve the ide context', () => {
+      const testFile = {
+        workspaceState: {
+          openFiles: [
+            {
+              path: '/path/to/test/file.ts',
+              isActive: true,
+              selectedText: '1234',
+              timestamp: 0,
+            },
+          ],
+        },
+      };
+
+      ideContext.setIdeContext(testFile);
+
+      const activeFile = ideContext.getIdeContext();
+      expect(activeFile).toEqual(testFile);
+    });
+
+    it('should update the ide context when called multiple times', () => {
+      const firstFile = {
+        workspaceState: {
+          openFiles: [
+            {
+              path: '/path/to/first.js',
+              isActive: true,
+              selectedText: '1234',
+              timestamp: 0,
+            },
+          ],
+        },
+      };
+      ideContext.setIdeContext(firstFile);
+
+      const secondFile = {
+        workspaceState: {
+          openFiles: [
+            {
+              path: '/path/to/second.py',
+              isActive: true,
+              cursor: { line: 20, character: 30 },
+              timestamp: 0,
+            },
+          ],
+        },
+      };
+      ideContext.setIdeContext(secondFile);
+
+      const activeFile = ideContext.getIdeContext();
+      expect(activeFile).toEqual(secondFile);
+    });
+
+    it('should handle empty string for file path', () => {
+      const testFile = {
+        workspaceState: {
+          openFiles: [
+            {
+              path: '',
+              isActive: true,
+              selectedText: '1234',
+              timestamp: 0,
+            },
+          ],
+        },
+      };
+      ideContext.setIdeContext(testFile);
+      expect(ideContext.getIdeContext()).toEqual(testFile);
+    });
+
+    it('should notify subscribers when ide context changes', () => {
+      const subscriber1 = vi.fn();
+      const subscriber2 = vi.fn();
+
+      ideContext.subscribeToIdeContext(subscriber1);
+      ideContext.subscribeToIdeContext(subscriber2);
+
+      const testFile = {
+        workspaceState: {
+          openFiles: [
+            {
+              path: '/path/to/subscribed.ts',
+              isActive: true,
+              cursor: { line: 15, character: 25 },
+              timestamp: 0,
+            },
+          ],
+        },
+      };
+      ideContext.setIdeContext(testFile);
+
+      expect(subscriber1).toHaveBeenCalledTimes(1);
+      expect(subscriber1).toHaveBeenCalledWith(testFile);
+      expect(subscriber2).toHaveBeenCalledTimes(1);
+      expect(subscriber2).toHaveBeenCalledWith(testFile);
+
+      // Test with another update
+      const newFile = {
+        workspaceState: {
+          openFiles: [
+            {
+              path: '/path/to/new.js',
+              isActive: true,
+              selectedText: '1234',
+              timestamp: 0,
+            },
+          ],
+        },
+      };
+      ideContext.setIdeContext(newFile);
+
+      expect(subscriber1).toHaveBeenCalledTimes(2);
+      expect(subscriber1).toHaveBeenCalledWith(newFile);
+      expect(subscriber2).toHaveBeenCalledTimes(2);
+      expect(subscriber2).toHaveBeenCalledWith(newFile);
+    });
+
+    it('should stop notifying a subscriber after unsubscribe', () => {
+      const subscriber1 = vi.fn();
+      const subscriber2 = vi.fn();
+
+      const unsubscribe1 = ideContext.subscribeToIdeContext(subscriber1);
+      ideContext.subscribeToIdeContext(subscriber2);
+
+      ideContext.setIdeContext({
+        workspaceState: {
+          openFiles: [
+            {
+              path: '/path/to/file1.txt',
+              isActive: true,
+              selectedText: '1234',
+              timestamp: 0,
+            },
+          ],
+        },
+      });
+      expect(subscriber1).toHaveBeenCalledTimes(1);
+      expect(subscriber2).toHaveBeenCalledTimes(1);
+
+      unsubscribe1();
+
+      ideContext.setIdeContext({
+        workspaceState: {
+          openFiles: [
+            {
+              path: '/path/to/file2.txt',
+              isActive: true,
+              selectedText: '1234',
+              timestamp: 0,
+            },
+          ],
+        },
+      });
+      expect(subscriber1).toHaveBeenCalledTimes(1); // Should not be called again
+      expect(subscriber2).toHaveBeenCalledTimes(2);
+    });
+
+    it('should clear the ide context', () => {
+      const testFile = {
+        workspaceState: {
+          openFiles: [
+            {
+              path: '/path/to/test/file.ts',
+              isActive: true,
+              selectedText: '1234',
+              timestamp: 0,
+            },
+          ],
+        },
+      };
+
+      ideContext.setIdeContext(testFile);
+
+      expect(ideContext.getIdeContext()).toEqual(testFile);
+
+      ideContext.clearIdeContext();
+
+      expect(ideContext.getIdeContext()).toBeUndefined();
+    });
+  });
+
+  describe('FileSchema', () => {
+    it('should validate a file with only required fields', () => {
+      const file = {
+        path: '/path/to/file.ts',
+        timestamp: 12345,
+      };
+      const result = FileSchema.safeParse(file);
+      expect(result.success).toBe(true);
+    });
+
+    it('should validate a file with all fields', () => {
+      const file = {
+        path: '/path/to/file.ts',
+        timestamp: 12345,
+        isActive: true,
+        selectedText: 'const x = 1;',
+        cursor: {
+          line: 10,
+          character: 20,
+        },
+      };
+      const result = FileSchema.safeParse(file);
+      expect(result.success).toBe(true);
+    });
+
+    it('should fail validation if path is missing', () => {
+      const file = {
+        timestamp: 12345,
+      };
+      const result = FileSchema.safeParse(file);
+      expect(result.success).toBe(false);
+    });
+
+    it('should fail validation if timestamp is missing', () => {
+      const file = {
+        path: '/path/to/file.ts',
+      };
+      const result = FileSchema.safeParse(file);
+      expect(result.success).toBe(false);
+    });
+  });
+
+  describe('IdeContextSchema', () => {
+    it('should validate an empty context', () => {
+      const context = {};
+      const result = IdeContextSchema.safeParse(context);
+      expect(result.success).toBe(true);
+    });
+
+    it('should validate a context with an empty workspaceState', () => {
+      const context = {
+        workspaceState: {},
+      };
+      const result = IdeContextSchema.safeParse(context);
+      expect(result.success).toBe(true);
+    });
+
+    it('should validate a context with an empty openFiles array', () => {
+      const context = {
+        workspaceState: {
+          openFiles: [],
+        },
+      };
+      const result = IdeContextSchema.safeParse(context);
+      expect(result.success).toBe(true);
+    });
+
+    it('should validate a context with a valid file', () => {
+      const context = {
+        workspaceState: {
+          openFiles: [
+            {
+              path: '/path/to/file.ts',
+              timestamp: 12345,
+            },
+          ],
+        },
+      };
+      const result = IdeContextSchema.safeParse(context);
+      expect(result.success).toBe(true);
+    });
+
+    it('should fail validation with an invalid file', () => {
+      const context = {
+        workspaceState: {
+          openFiles: [
+            {
+              timestamp: 12345, // path is missing
+            },
+          ],
+        },
+      };
+      const result = IdeContextSchema.safeParse(context);
+      expect(result.success).toBe(false);
+    });
+  });
+});

projects/ui/qwen-code/packages/core/src/ide/ideContext.ts

@@ -0,0 +1,176 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { z } from 'zod';
+
+/**
+ * Zod schema for validating a file context from the IDE.
+ */
+export const FileSchema = z.object({
+  path: z.string(),
+  timestamp: z.number(),
+  isActive: z.boolean().optional(),
+  selectedText: z.string().optional(),
+  cursor: z
+    .object({
+      line: z.number(),
+      character: z.number(),
+    })
+    .optional(),
+});
+export type File = z.infer<typeof FileSchema>;
+
+export const IdeContextSchema = z.object({
+  workspaceState: z
+    .object({
+      openFiles: z.array(FileSchema).optional(),
+    })
+    .optional(),
+});
+export type IdeContext = z.infer<typeof IdeContextSchema>;
+
+/**
+ * Zod schema for validating the 'ide/contextUpdate' notification from the IDE.
+ */
+export const IdeContextNotificationSchema = z.object({
+  jsonrpc: z.literal('2.0'),
+  method: z.literal('ide/contextUpdate'),
+  params: IdeContextSchema,
+});
+
+export const IdeDiffAcceptedNotificationSchema = z.object({
+  jsonrpc: z.literal('2.0'),
+  method: z.literal('ide/diffAccepted'),
+  params: z.object({
+    filePath: z.string(),
+    content: z.string(),
+  }),
+});
+
+export const IdeDiffClosedNotificationSchema = z.object({
+  jsonrpc: z.literal('2.0'),
+  method: z.literal('ide/diffClosed'),
+  params: z.object({
+    filePath: z.string(),
+    content: z.string().optional(),
+  }),
+});
+
+export const CloseDiffResponseSchema = z
+  .object({
+    content: z
+      .array(
+        z.object({
+          text: z.string(),
+          type: z.literal('text'),
+        }),
+      )
+      .min(1),
+  })
+  .transform((val, ctx) => {
+    try {
+      const parsed = JSON.parse(val.content[0].text);
+      const innerSchema = z.object({ content: z.string().optional() });
+      const validationResult = innerSchema.safeParse(parsed);
+      if (!validationResult.success) {
+        validationResult.error.issues.forEach((issue) => ctx.addIssue(issue));
+        return z.NEVER;
+      }
+      return validationResult.data;
+    } catch (_) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: 'Invalid JSON in text content',
+      });
+      return z.NEVER;
+    }
+  });
+
+export type DiffUpdateResult =
+  | {
+      status: 'accepted';
+      content?: string;
+    }
+  | {
+      status: 'rejected';
+      content: undefined;
+    };
+
+type IdeContextSubscriber = (ideContext: IdeContext | undefined) => void;
+
+/**
+ * Creates a new store for managing the IDE's context.
+ * This factory function encapsulates the state and logic, allowing for the creation
+ * of isolated instances, which is particularly useful for testing.
+ *
+ * @returns An object with methods to interact with the IDE context.
+ */
+export function createIdeContextStore() {
+  let ideContextState: IdeContext | undefined = undefined;
+  const subscribers = new Set<IdeContextSubscriber>();
+
+  /**
+   * Notifies all registered subscribers about the current IDE context.
+   */
+  function notifySubscribers(): void {
+    for (const subscriber of subscribers) {
+      subscriber(ideContextState);
+    }
+  }
+
+  /**
+   * Sets the IDE context and notifies all registered subscribers of the change.
+   * @param newIdeContext The new IDE context from the IDE.
+   */
+  function setIdeContext(newIdeContext: IdeContext): void {
+    ideContextState = newIdeContext;
+    notifySubscribers();
+  }
+
+  /**
+   * Clears the IDE context and notifies all registered subscribers of the change.
+   */
+  function clearIdeContext(): void {
+    ideContextState = undefined;
+    notifySubscribers();
+  }
+
+  /**
+   * Retrieves the current IDE context.
+   * @returns The `IdeContext` object if a file is active; otherwise, `undefined`.
+   */
+  function getIdeContext(): IdeContext | undefined {
+    return ideContextState;
+  }
+
+  /**
+   * Subscribes to changes in the IDE context.
+   *
+   * When the IDE context changes, the provided `subscriber` function will be called.
+   * Note: The subscriber is not called with the current value upon subscription.
+   *
+   * @param subscriber The function to be called when the IDE context changes.
+   * @returns A function that, when called, will unsubscribe the provided subscriber.
+   */
+  function subscribeToIdeContext(subscriber: IdeContextSubscriber): () => void {
+    subscribers.add(subscriber);
+    return () => {
+      subscribers.delete(subscriber);
+    };
+  }
+
+  return {
+    setIdeContext,
+    getIdeContext,
+    subscribeToIdeContext,
+    clearIdeContext,
+  };
+}
+
+/**
+ * The default, shared instance of the IDE context store for the application.
+ */
+export const ideContext = createIdeContextStore();

projects/ui/qwen-code/packages/core/src/ide/process-utils.ts

@@ -0,0 +1,157 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import os from 'os';
+import path from 'path';
+
+const execAsync = promisify(exec);
+
+const MAX_TRAVERSAL_DEPTH = 32;
+
+/**
+ * Fetches the parent process ID and name for a given process ID.
+ *
+ * @param pid The process ID to inspect.
+ * @returns A promise that resolves to the parent's PID and name.
+ */
+async function getParentProcessInfo(pid: number): Promise<{
+  parentPid: number;
+  name: string;
+}> {
+  const platform = os.platform();
+  if (platform === 'win32') {
+    const command = `wmic process where "ProcessId=${pid}" get Name,ParentProcessId /value`;
+    const { stdout } = await execAsync(command);
+    const nameMatch = stdout.match(/Name=([^\n]*)/);
+    const processName = nameMatch ? nameMatch[1].trim() : '';
+    const ppidMatch = stdout.match(/ParentProcessId=(\d+)/);
+    const parentPid = ppidMatch ? parseInt(ppidMatch[1], 10) : 0;
+    return { parentPid, name: processName };
+  } else {
+    const command = `ps -o ppid=,command= -p ${pid}`;
+    const { stdout } = await execAsync(command);
+    const trimmedStdout = stdout.trim();
+    const ppidString = trimmedStdout.split(/\s+/)[0];
+    const parentPid = parseInt(ppidString, 10);
+    const fullCommand = trimmedStdout.substring(ppidString.length).trim();
+    const processName = path.basename(fullCommand.split(' ')[0]);
+    return { parentPid: isNaN(parentPid) ? 1 : parentPid, name: processName };
+  }
+}
+
+/**
+ * Traverses the process tree on Unix-like systems to find the IDE process ID.
+ *
+ * The strategy is to find the shell process that spawned the CLI, and then
+ * find that shell's parent process (the IDE). To get the true IDE process,
+ * we traverse one level higher to get the grandparent.
+ *
+ * @returns A promise that resolves to the numeric PID.
+ */
+async function getIdeProcessIdForUnix(): Promise<number> {
+  const shells = ['zsh', 'bash', 'sh', 'tcsh', 'csh', 'ksh', 'fish', 'dash'];
+  let currentPid = process.pid;
+
+  for (let i = 0; i < MAX_TRAVERSAL_DEPTH; i++) {
+    try {
+      const { parentPid, name } = await getParentProcessInfo(currentPid);
+
+      const isShell = shells.some((shell) => name === shell);
+      if (isShell) {
+        // The direct parent of the shell is often a utility process (e.g. VS
+        // Code's `ptyhost` process). To get the true IDE process, we need to
+        // traverse one level higher to get the grandparent.
+        try {
+          const { parentPid: grandParentPid } =
+            await getParentProcessInfo(parentPid);
+          if (grandParentPid > 1) {
+            return grandParentPid;
+          }
+        } catch {
+          // Ignore if getting grandparent fails, we'll just use the parent pid.
+        }
+        return parentPid;
+      }
+
+      if (parentPid <= 1) {
+        break; // Reached the root
+      }
+      currentPid = parentPid;
+    } catch {
+      // Process in chain died
+      break;
+    }
+  }
+
+  console.error(
+    'Failed to find shell process in the process tree. Falling back to top-level process, which may be inaccurate. If you see this, please file a bug via /bug.',
+  );
+  return currentPid;
+}
+
+/**
+ * Traverses the process tree on Windows to find the IDE process ID.
+ *
+ * The strategy is to find the grandchild of the root process.
+ *
+ * @returns A promise that resolves to the numeric PID.
+ */
+async function getIdeProcessIdForWindows(): Promise<number> {
+  let currentPid = process.pid;
+
+  for (let i = 0; i < MAX_TRAVERSAL_DEPTH; i++) {
+    try {
+      const { parentPid } = await getParentProcessInfo(currentPid);
+
+      if (parentPid > 0) {
+        try {
+          const { parentPid: grandParentPid } =
+            await getParentProcessInfo(parentPid);
+          if (grandParentPid === 0) {
+            // Found grandchild of root
+            return currentPid;
+          }
+        } catch {
+          // getting grandparent failed, proceed
+        }
+      }
+
+      if (parentPid <= 0) {
+        break; // Reached the root
+      }
+      currentPid = parentPid;
+    } catch {
+      // Process in chain died
+      break;
+    }
+  }
+  return currentPid;
+}
+
+/**
+ * Traverses up the process tree to find the process ID of the IDE.
+ *
+ * This function uses different strategies depending on the operating system
+ * to identify the main application process (e.g., the main VS Code window
+ * process).
+ *
+ * If the IDE process cannot be reliably identified, it will return the
+ * top-level ancestor process ID as a fallback.
+ *
+ * @returns A promise that resolves to the numeric PID of the IDE process.
+ * @throws Will throw an error if the underlying shell commands fail.
+ */
+export async function getIdeProcessId(): Promise<number> {
+  const platform = os.platform();
+
+  if (platform === 'win32') {
+    return getIdeProcessIdForWindows();
+  }
+
+  return getIdeProcessIdForUnix();
+}

projects/ui/qwen-code/packages/core/src/mcp/google-auth-provider.test.ts

@@ -0,0 +1,111 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { GoogleAuth } from 'google-auth-library';
+import { GoogleCredentialProvider } from './google-auth-provider.js';
+import { vi, describe, beforeEach, it, expect, Mock } from 'vitest';
+import { MCPServerConfig } from '../config/config.js';
+
+vi.mock('google-auth-library');
+
+describe('GoogleCredentialProvider', () => {
+  const validConfig = {
+    url: 'https://test.googleapis.com',
+    oauth: {
+      scopes: ['scope1', 'scope2'],
+    },
+  } as MCPServerConfig;
+
+  it('should throw an error if no scopes are provided', () => {
+    const config = {
+      url: 'https://test.googleapis.com',
+    } as MCPServerConfig;
+    expect(() => new GoogleCredentialProvider(config)).toThrow(
+      'Scopes must be provided in the oauth config for Google Credentials provider',
+    );
+  });
+
+  it('should use scopes from the config if provided', () => {
+    new GoogleCredentialProvider(validConfig);
+    expect(GoogleAuth).toHaveBeenCalledWith({
+      scopes: ['scope1', 'scope2'],
+    });
+  });
+
+  it('should throw an error for a non-allowlisted host', () => {
+    const config = {
+      url: 'https://example.com',
+      oauth: {
+        scopes: ['scope1', 'scope2'],
+      },
+    } as MCPServerConfig;
+    expect(() => new GoogleCredentialProvider(config)).toThrow(
+      'Host "example.com" is not an allowed host for Google Credential provider.',
+    );
+  });
+
+  it('should allow luci.app', () => {
+    const config = {
+      url: 'https://luci.app',
+      oauth: {
+        scopes: ['scope1', 'scope2'],
+      },
+    } as MCPServerConfig;
+    new GoogleCredentialProvider(config);
+  });
+
+  it('should allow sub.luci.app', () => {
+    const config = {
+      url: 'https://sub.luci.app',
+      oauth: {
+        scopes: ['scope1', 'scope2'],
+      },
+    } as MCPServerConfig;
+    new GoogleCredentialProvider(config);
+  });
+
+  it('should not allow googleapis.com without a subdomain', () => {
+    const config = {
+      url: 'https://googleapis.com',
+      oauth: {
+        scopes: ['scope1', 'scope2'],
+      },
+    } as MCPServerConfig;
+    expect(() => new GoogleCredentialProvider(config)).toThrow(
+      'Host "googleapis.com" is not an allowed host for Google Credential provider.',
+    );
+  });
+
+  describe('with provider instance', () => {
+    let provider: GoogleCredentialProvider;
+
+    beforeEach(() => {
+      provider = new GoogleCredentialProvider(validConfig);
+      vi.clearAllMocks();
+    });
+
+    it('should return credentials', async () => {
+      const mockClient = {
+        getAccessToken: vi.fn().mockResolvedValue({ token: 'test-token' }),
+      };
+      (GoogleAuth.prototype.getClient as Mock).mockResolvedValue(mockClient);
+
+      const credentials = await provider.tokens();
+
+      expect(credentials?.access_token).toBe('test-token');
+    });
+
+    it('should return undefined if access token is not available', async () => {
+      const mockClient = {
+        getAccessToken: vi.fn().mockResolvedValue({ token: null }),
+      };
+      (GoogleAuth.prototype.getClient as Mock).mockResolvedValue(mockClient);
+
+      const credentials = await provider.tokens();
+      expect(credentials).toBeUndefined();
+    });
+  });
+});

projects/ui/qwen-code/packages/core/src/mcp/google-auth-provider.ts

@@ -0,0 +1,99 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { OAuthClientProvider } from '@modelcontextprotocol/sdk/client/auth.js';
+import {
+  OAuthClientInformation,
+  OAuthClientInformationFull,
+  OAuthClientMetadata,
+  OAuthTokens,
+} from '@modelcontextprotocol/sdk/shared/auth.js';
+import { GoogleAuth } from 'google-auth-library';
+import { MCPServerConfig } from '../config/config.js';
+
+const ALLOWED_HOSTS = [/^.+\.googleapis\.com$/, /^(.*\.)?luci\.app$/];
+
+export class GoogleCredentialProvider implements OAuthClientProvider {
+  private readonly auth: GoogleAuth;
+
+  // Properties required by OAuthClientProvider, with no-op values
+  readonly redirectUrl = '';
+  readonly clientMetadata: OAuthClientMetadata = {
+    client_name: 'Gemini CLI (Google ADC)',
+    redirect_uris: [],
+    grant_types: [],
+    response_types: [],
+    token_endpoint_auth_method: 'none',
+  };
+  private _clientInformation?: OAuthClientInformationFull;
+
+  constructor(private readonly config?: MCPServerConfig) {
+    const url = this.config?.url || this.config?.httpUrl;
+    if (!url) {
+      throw new Error(
+        'URL must be provided in the config for Google Credentials provider',
+      );
+    }
+
+    const hostname = new URL(url).hostname;
+    if (!ALLOWED_HOSTS.some((pattern) => pattern.test(hostname))) {
+      throw new Error(
+        `Host "${hostname}" is not an allowed host for Google Credential provider.`,
+      );
+    }
+
+    const scopes = this.config?.oauth?.scopes;
+    if (!scopes || scopes.length === 0) {
+      throw new Error(
+        'Scopes must be provided in the oauth config for Google Credentials provider',
+      );
+    }
+    this.auth = new GoogleAuth({
+      scopes,
+    });
+  }
+
+  clientInformation(): OAuthClientInformation | undefined {
+    return this._clientInformation;
+  }
+
+  saveClientInformation(clientInformation: OAuthClientInformationFull): void {
+    this._clientInformation = clientInformation;
+  }
+
+  async tokens(): Promise<OAuthTokens | undefined> {
+    const client = await this.auth.getClient();
+    const accessTokenResponse = await client.getAccessToken();
+
+    if (!accessTokenResponse.token) {
+      console.error('Failed to get access token from Google ADC');
+      return undefined;
+    }
+
+    const tokens: OAuthTokens = {
+      access_token: accessTokenResponse.token,
+      token_type: 'Bearer',
+    };
+    return tokens;
+  }
+
+  saveTokens(_tokens: OAuthTokens): void {
+    // No-op, ADC manages tokens.
+  }
+
+  redirectToAuthorization(_authorizationUrl: URL): void {
+    // No-op
+  }
+
+  saveCodeVerifier(_codeVerifier: string): void {
+    // No-op
+  }
+
+  codeVerifier(): string {
+    // No-op
+    return '';
+  }
+}

projects/ui/qwen-code/packages/core/src/mcp/oauth-provider.test.ts

@@ -0,0 +1,957 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { vi } from 'vitest';
+
+// Mock dependencies AT THE TOP
+const mockOpenBrowserSecurely = vi.hoisted(() => vi.fn());
+vi.mock('../utils/secure-browser-launcher.js', () => ({
+  openBrowserSecurely: mockOpenBrowserSecurely,
+}));
+vi.mock('node:crypto');
+vi.mock('./oauth-token-storage.js');
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import * as http from 'node:http';
+import * as crypto from 'node:crypto';
+import {
+  MCPOAuthProvider,
+  MCPOAuthConfig,
+  OAuthTokenResponse,
+  OAuthClientRegistrationResponse,
+} from './oauth-provider.js';
+import { MCPOAuthTokenStorage, MCPOAuthToken } from './oauth-token-storage.js';
+
+// Mock fetch globally
+const mockFetch = vi.fn();
+global.fetch = mockFetch;
+
+// Helper function to create mock fetch responses with proper headers
+const createMockResponse = (options: {
+  ok: boolean;
+  status?: number;
+  contentType?: string;
+  text?: string | (() => Promise<string>);
+  json?: unknown | (() => Promise<unknown>);
+}) => {
+  const response: {
+    ok: boolean;
+    status?: number;
+    headers: {
+      get: (name: string) => string | null;
+    };
+    text?: () => Promise<string>;
+    json?: () => Promise<unknown>;
+  } = {
+    ok: options.ok,
+    headers: {
+      get: (name: string) => {
+        if (name.toLowerCase() === 'content-type') {
+          return options.contentType || null;
+        }
+        return null;
+      },
+    },
+  };
+
+  if (options.status !== undefined) {
+    response.status = options.status;
+  }
+
+  if (options.text !== undefined) {
+    response.text =
+      typeof options.text === 'string'
+        ? () => Promise.resolve(options.text as string)
+        : (options.text as () => Promise<string>);
+  }
+
+  if (options.json !== undefined) {
+    response.json =
+      typeof options.json === 'function'
+        ? (options.json as () => Promise<unknown>)
+        : () => Promise.resolve(options.json);
+  }
+
+  return response;
+};
+
+// Define a reusable mock server with .listen, .close, and .on methods
+const mockHttpServer = {
+  listen: vi.fn(),
+  close: vi.fn(),
+  on: vi.fn(),
+};
+vi.mock('node:http', () => ({
+  createServer: vi.fn(() => mockHttpServer),
+}));
+
+describe('MCPOAuthProvider', () => {
+  const mockConfig: MCPOAuthConfig = {
+    enabled: true,
+    clientId: 'test-client-id',
+    clientSecret: 'test-client-secret',
+    authorizationUrl: 'https://auth.example.com/authorize',
+    tokenUrl: 'https://auth.example.com/token',
+    scopes: ['read', 'write'],
+    redirectUri: 'http://localhost:7777/oauth/callback',
+    audiences: ['https://api.example.com'],
+  };
+
+  const mockToken: MCPOAuthToken = {
+    accessToken: 'access_token_123',
+    refreshToken: 'refresh_token_456',
+    tokenType: 'Bearer',
+    scope: 'read write',
+    expiresAt: Date.now() + 3600000,
+  };
+
+  const mockTokenResponse: OAuthTokenResponse = {
+    access_token: 'access_token_123',
+    token_type: 'Bearer',
+    expires_in: 3600,
+    refresh_token: 'refresh_token_456',
+    scope: 'read write',
+  };
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockOpenBrowserSecurely.mockClear();
+    vi.spyOn(console, 'log').mockImplementation(() => {});
+    vi.spyOn(console, 'warn').mockImplementation(() => {});
+    vi.spyOn(console, 'error').mockImplementation(() => {});
+
+    // Mock crypto functions
+    vi.mocked(crypto.randomBytes).mockImplementation((size: number) => {
+      if (size === 32) return Buffer.from('code_verifier_mock_32_bytes_long');
+      if (size === 16) return Buffer.from('state_mock_16_by');
+      return Buffer.alloc(size);
+    });
+
+    vi.mocked(crypto.createHash).mockReturnValue({
+      update: vi.fn().mockReturnThis(),
+      digest: vi.fn().mockReturnValue('code_challenge_mock'),
+    } as unknown as crypto.Hash);
+
+    // Mock randomBytes to return predictable values for state
+    vi.mocked(crypto.randomBytes).mockImplementation((size) => {
+      if (size === 32) {
+        return Buffer.from('mock_code_verifier_32_bytes_long_string');
+      } else if (size === 16) {
+        return Buffer.from('mock_state_16_bytes');
+      }
+      return Buffer.alloc(size);
+    });
+
+    // Mock token storage
+    vi.mocked(MCPOAuthTokenStorage.saveToken).mockResolvedValue(undefined);
+    vi.mocked(MCPOAuthTokenStorage.getToken).mockResolvedValue(null);
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  describe('authenticate', () => {
+    it('should perform complete OAuth flow with PKCE', async () => {
+      // Mock HTTP server callback
+      let callbackHandler: unknown;
+      vi.mocked(http.createServer).mockImplementation((handler) => {
+        callbackHandler = handler;
+        return mockHttpServer as unknown as http.Server;
+      });
+
+      mockHttpServer.listen.mockImplementation((port, callback) => {
+        callback?.();
+        // Simulate OAuth callback
+        setTimeout(() => {
+          const mockReq = {
+            url: '/oauth/callback?code=auth_code_123&state=bW9ja19zdGF0ZV8xNl9ieXRlcw',
+          };
+          const mockRes = {
+            writeHead: vi.fn(),
+            end: vi.fn(),
+          };
+          (callbackHandler as (req: unknown, res: unknown) => void)(
+            mockReq,
+            mockRes,
+          );
+        }, 10);
+      });
+
+      // Mock token exchange
+      mockFetch.mockResolvedValueOnce(
+        createMockResponse({
+          ok: true,
+          contentType: 'application/json',
+          text: JSON.stringify(mockTokenResponse),
+          json: mockTokenResponse,
+        }),
+      );
+
+      const result = await MCPOAuthProvider.authenticate(
+        'test-server',
+        mockConfig,
+      );
+
+      expect(result).toEqual({
+        accessToken: 'access_token_123',
+        refreshToken: 'refresh_token_456',
+        tokenType: 'Bearer',
+        scope: 'read write',
+        expiresAt: expect.any(Number),
+      });
+
+      expect(mockOpenBrowserSecurely).toHaveBeenCalledWith(
+        expect.stringContaining('authorize'),
+      );
+      expect(MCPOAuthTokenStorage.saveToken).toHaveBeenCalledWith(
+        'test-server',
+        expect.objectContaining({ accessToken: 'access_token_123' }),
+        'test-client-id',
+        'https://auth.example.com/token',
+        undefined,
+      );
+    });
+
+    it('should handle OAuth discovery when no authorization URL provided', async () => {
+      // Use a mutable config object
+      const configWithoutAuth: MCPOAuthConfig = {
+        ...mockConfig,
+        clientId: 'test-client-id',
+        clientSecret: 'test-client-secret',
+      };
+      delete configWithoutAuth.authorizationUrl;
+      delete configWithoutAuth.tokenUrl;
+
+      const mockResourceMetadata = {
+        authorization_servers: ['https://discovered.auth.com'],
+      };
+
+      const mockAuthServerMetadata = {
+        authorization_endpoint: 'https://discovered.auth.com/authorize',
+        token_endpoint: 'https://discovered.auth.com/token',
+        scopes_supported: ['read', 'write'],
+      };
+
+      // Mock HEAD request for WWW-Authenticate check
+      mockFetch
+        .mockResolvedValueOnce(
+          createMockResponse({
+            ok: true,
+            status: 200,
+          }),
+        )
+        .mockResolvedValueOnce(
+          createMockResponse({
+            ok: true,
+            contentType: 'application/json',
+            text: JSON.stringify(mockResourceMetadata),
+            json: mockResourceMetadata,
+          }),
+        )
+        .mockResolvedValueOnce(
+          createMockResponse({
+            ok: true,
+            contentType: 'application/json',
+            text: JSON.stringify(mockAuthServerMetadata),
+            json: mockAuthServerMetadata,
+          }),
+        );
+
+      // Setup callback handler
+      let callbackHandler: unknown;
+      vi.mocked(http.createServer).mockImplementation((handler) => {
+        callbackHandler = handler;
+        return mockHttpServer as unknown as http.Server;
+      });
+
+      mockHttpServer.listen.mockImplementation((port, callback) => {
+        callback?.();
+        setTimeout(() => {
+          const mockReq = {
+            url: '/oauth/callback?code=auth_code_123&state=bW9ja19zdGF0ZV8xNl9ieXRlcw',
+          };
+          const mockRes = {
+            writeHead: vi.fn(),
+            end: vi.fn(),
+          };
+          (callbackHandler as (req: unknown, res: unknown) => void)(
+            mockReq,
+            mockRes,
+          );
+        }, 10);
+      });
+
+      // Mock token exchange with discovered endpoint
+      mockFetch.mockResolvedValueOnce(
+        createMockResponse({
+          ok: true,
+          contentType: 'application/json',
+          text: JSON.stringify(mockTokenResponse),
+          json: mockTokenResponse,
+        }),
+      );
+
+      const result = await MCPOAuthProvider.authenticate(
+        'test-server',
+        configWithoutAuth,
+        'https://api.example.com',
+      );
+
+      expect(result).toBeDefined();
+      expect(mockFetch).toHaveBeenCalledWith(
+        'https://discovered.auth.com/token',
+        expect.objectContaining({
+          method: 'POST',
+          headers: expect.objectContaining({
+            'Content-Type': 'application/x-www-form-urlencoded',
+          }),
+        }),
+      );
+    });
+
+    it('should perform dynamic client registration when no client ID provided', async () => {
+      const configWithoutClient = { ...mockConfig };
+      delete configWithoutClient.clientId;
+
+      const mockRegistrationResponse: OAuthClientRegistrationResponse = {
+        client_id: 'dynamic_client_id',
+        client_secret: 'dynamic_client_secret',
+        redirect_uris: ['http://localhost:7777/oauth/callback'],
+        grant_types: ['authorization_code', 'refresh_token'],
+        response_types: ['code'],
+        token_endpoint_auth_method: 'none',
+      };
+
+      const mockAuthServerMetadata = {
+        authorization_endpoint: 'https://auth.example.com/authorize',
+        token_endpoint: 'https://auth.example.com/token',
+        registration_endpoint: 'https://auth.example.com/register',
+      };
+
+      mockFetch
+        .mockResolvedValueOnce(
+          createMockResponse({
+            ok: true,
+            contentType: 'application/json',
+            text: JSON.stringify(mockAuthServerMetadata),
+            json: mockAuthServerMetadata,
+          }),
+        )
+        .mockResolvedValueOnce(
+          createMockResponse({
+            ok: true,
+            contentType: 'application/json',
+            text: JSON.stringify(mockRegistrationResponse),
+            json: mockRegistrationResponse,
+          }),
+        );
+
+      // Setup callback handler
+      let callbackHandler: unknown;
+      vi.mocked(http.createServer).mockImplementation((handler) => {
+        callbackHandler = handler;
+        return mockHttpServer as unknown as http.Server;
+      });
+
+      mockHttpServer.listen.mockImplementation((port, callback) => {
+        callback?.();
+        setTimeout(() => {
+          const mockReq = {
+            url: '/oauth/callback?code=auth_code_123&state=bW9ja19zdGF0ZV8xNl9ieXRlcw',
+          };
+          const mockRes = {
+            writeHead: vi.fn(),
+            end: vi.fn(),
+          };
+          (callbackHandler as (req: unknown, res: unknown) => void)(
+            mockReq,
+            mockRes,
+          );
+        }, 10);
+      });
+
+      // Mock token exchange
+      mockFetch.mockResolvedValueOnce(
+        createMockResponse({
+          ok: true,
+          contentType: 'application/json',
+          text: JSON.stringify(mockTokenResponse),
+          json: mockTokenResponse,
+        }),
+      );
+
+      const result = await MCPOAuthProvider.authenticate(
+        'test-server',
+        configWithoutClient,
+      );
+
+      expect(result).toBeDefined();
+      expect(mockFetch).toHaveBeenCalledWith(
+        'https://auth.example.com/register',
+        expect.objectContaining({
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+        }),
+      );
+    });
+
+    it('should handle OAuth callback errors', async () => {
+      let callbackHandler: unknown;
+      vi.mocked(http.createServer).mockImplementation((handler) => {
+        callbackHandler = handler;
+        return mockHttpServer as unknown as http.Server;
+      });
+
+      mockHttpServer.listen.mockImplementation((port, callback) => {
+        callback?.();
+        setTimeout(() => {
+          const mockReq = {
+            url: '/oauth/callback?error=access_denied&error_description=User%20denied%20access',
+          };
+          const mockRes = {
+            writeHead: vi.fn(),
+            end: vi.fn(),
+          };
+          (callbackHandler as (req: unknown, res: unknown) => void)(
+            mockReq,
+            mockRes,
+          );
+        }, 10);
+      });
+
+      await expect(
+        MCPOAuthProvider.authenticate('test-server', mockConfig),
+      ).rejects.toThrow('OAuth error: access_denied');
+    });
+
+    it('should handle state mismatch in callback', async () => {
+      let callbackHandler: unknown;
+      vi.mocked(http.createServer).mockImplementation((handler) => {
+        callbackHandler = handler;
+        return mockHttpServer as unknown as http.Server;
+      });
+
+      mockHttpServer.listen.mockImplementation((port, callback) => {
+        callback?.();
+        setTimeout(() => {
+          const mockReq = {
+            url: '/oauth/callback?code=auth_code_123&state=wrong_state',
+          };
+          const mockRes = {
+            writeHead: vi.fn(),
+            end: vi.fn(),
+          };
+          (callbackHandler as (req: unknown, res: unknown) => void)(
+            mockReq,
+            mockRes,
+          );
+        }, 10);
+      });
+
+      await expect(
+        MCPOAuthProvider.authenticate('test-server', mockConfig),
+      ).rejects.toThrow('State mismatch - possible CSRF attack');
+    });
+
+    it('should handle token exchange failure', async () => {
+      let callbackHandler: unknown;
+      vi.mocked(http.createServer).mockImplementation((handler) => {
+        callbackHandler = handler;
+        return mockHttpServer as unknown as http.Server;
+      });
+
+      mockHttpServer.listen.mockImplementation((port, callback) => {
+        callback?.();
+        setTimeout(() => {
+          const mockReq = {
+            url: '/oauth/callback?code=auth_code_123&state=bW9ja19zdGF0ZV8xNl9ieXRlcw',
+          };
+          const mockRes = {
+            writeHead: vi.fn(),
+            end: vi.fn(),
+          };
+          (callbackHandler as (req: unknown, res: unknown) => void)(
+            mockReq,
+            mockRes,
+          );
+        }, 10);
+      });
+
+      mockFetch.mockResolvedValueOnce(
+        createMockResponse({
+          ok: false,
+          status: 400,
+          contentType: 'application/x-www-form-urlencoded',
+          text: 'error=invalid_grant&error_description=Invalid grant',
+        }),
+      );
+
+      await expect(
+        MCPOAuthProvider.authenticate('test-server', mockConfig),
+      ).rejects.toThrow('Token exchange failed: invalid_grant - Invalid grant');
+    });
+
+    it('should handle callback timeout', async () => {
+      vi.mocked(http.createServer).mockImplementation(
+        () => mockHttpServer as unknown as http.Server,
+      );
+
+      mockHttpServer.listen.mockImplementation((port, callback) => {
+        callback?.();
+        // Don't trigger callback - simulate timeout
+      });
+
+      // Mock setTimeout to trigger timeout immediately
+      const originalSetTimeout = global.setTimeout;
+      global.setTimeout = vi.fn((callback, delay) => {
+        if (delay === 5 * 60 * 1000) {
+          // 5 minute timeout
+          callback();
+        }
+        return originalSetTimeout(callback, 0);
+      }) as unknown as typeof setTimeout;
+
+      await expect(
+        MCPOAuthProvider.authenticate('test-server', mockConfig),
+      ).rejects.toThrow('OAuth callback timeout');
+
+      global.setTimeout = originalSetTimeout;
+    });
+  });
+
+  describe('refreshAccessToken', () => {
+    it('should refresh token successfully', async () => {
+      const refreshResponse = {
+        access_token: 'new_access_token',
+        token_type: 'Bearer',
+        expires_in: 3600,
+        refresh_token: 'new_refresh_token',
+      };
+
+      mockFetch.mockResolvedValueOnce(
+        createMockResponse({
+          ok: true,
+          contentType: 'application/json',
+          text: JSON.stringify(refreshResponse),
+          json: refreshResponse,
+        }),
+      );
+
+      const result = await MCPOAuthProvider.refreshAccessToken(
+        mockConfig,
+        'old_refresh_token',
+        'https://auth.example.com/token',
+      );
+
+      expect(result).toEqual(refreshResponse);
+      expect(mockFetch).toHaveBeenCalledWith(
+        'https://auth.example.com/token',
+        expect.objectContaining({
+          method: 'POST',
+          headers: {
+            'Content-Type': 'application/x-www-form-urlencoded',
+            Accept: 'application/json, application/x-www-form-urlencoded',
+          },
+          body: expect.stringContaining('grant_type=refresh_token'),
+        }),
+      );
+    });
+
+    it('should include client secret in refresh request when available', async () => {
+      mockFetch.mockResolvedValueOnce(
+        createMockResponse({
+          ok: true,
+          contentType: 'application/json',
+          text: JSON.stringify(mockTokenResponse),
+          json: mockTokenResponse,
+        }),
+      );
+
+      await MCPOAuthProvider.refreshAccessToken(
+        mockConfig,
+        'refresh_token',
+        'https://auth.example.com/token',
+      );
+
+      const fetchCall = mockFetch.mock.calls[0];
+      expect(fetchCall[1].body).toContain('client_secret=test-client-secret');
+    });
+
+    it('should handle refresh token failure', async () => {
+      mockFetch.mockResolvedValueOnce(
+        createMockResponse({
+          ok: false,
+          status: 400,
+          contentType: 'application/x-www-form-urlencoded',
+          text: 'error=invalid_request&error_description=Invalid refresh token',
+        }),
+      );
+
+      await expect(
+        MCPOAuthProvider.refreshAccessToken(
+          mockConfig,
+          'invalid_refresh_token',
+          'https://auth.example.com/token',
+        ),
+      ).rejects.toThrow(
+        'Token refresh failed: invalid_request - Invalid refresh token',
+      );
+    });
+  });
+
+  describe('getValidToken', () => {
+    it('should return valid token when not expired', async () => {
+      const validCredentials = {
+        serverName: 'test-server',
+        token: mockToken,
+        clientId: 'test-client-id',
+        tokenUrl: 'https://auth.example.com/token',
+        updatedAt: Date.now(),
+      };
+
+      vi.mocked(MCPOAuthTokenStorage.getToken).mockResolvedValue(
+        validCredentials,
+      );
+      vi.mocked(MCPOAuthTokenStorage.isTokenExpired).mockReturnValue(false);
+
+      const result = await MCPOAuthProvider.getValidToken(
+        'test-server',
+        mockConfig,
+      );
+
+      expect(result).toBe('access_token_123');
+    });
+
+    it('should refresh expired token and return new token', async () => {
+      const expiredCredentials = {
+        serverName: 'test-server',
+        token: { ...mockToken, expiresAt: Date.now() - 3600000 },
+        clientId: 'test-client-id',
+        tokenUrl: 'https://auth.example.com/token',
+        updatedAt: Date.now(),
+      };
+
+      vi.mocked(MCPOAuthTokenStorage.getToken).mockResolvedValue(
+        expiredCredentials,
+      );
+      vi.mocked(MCPOAuthTokenStorage.isTokenExpired).mockReturnValue(true);
+
+      const refreshResponse = {
+        access_token: 'new_access_token',
+        token_type: 'Bearer',
+        expires_in: 3600,
+        refresh_token: 'new_refresh_token',
+      };
+
+      mockFetch.mockResolvedValueOnce(
+        createMockResponse({
+          ok: true,
+          contentType: 'application/json',
+          text: JSON.stringify(refreshResponse),
+          json: refreshResponse,
+        }),
+      );
+
+      const result = await MCPOAuthProvider.getValidToken(
+        'test-server',
+        mockConfig,
+      );
+
+      expect(result).toBe('new_access_token');
+      expect(MCPOAuthTokenStorage.saveToken).toHaveBeenCalledWith(
+        'test-server',
+        expect.objectContaining({ accessToken: 'new_access_token' }),
+        'test-client-id',
+        'https://auth.example.com/token',
+        undefined,
+      );
+    });
+
+    it('should return null when no credentials exist', async () => {
+      vi.mocked(MCPOAuthTokenStorage.getToken).mockResolvedValue(null);
+
+      const result = await MCPOAuthProvider.getValidToken(
+        'test-server',
+        mockConfig,
+      );
+
+      expect(result).toBeNull();
+    });
+
+    it('should handle refresh failure and remove invalid token', async () => {
+      const expiredCredentials = {
+        serverName: 'test-server',
+        token: { ...mockToken, expiresAt: Date.now() - 3600000 },
+        clientId: 'test-client-id',
+        tokenUrl: 'https://auth.example.com/token',
+        updatedAt: Date.now(),
+      };
+
+      vi.mocked(MCPOAuthTokenStorage.getToken).mockResolvedValue(
+        expiredCredentials,
+      );
+      vi.mocked(MCPOAuthTokenStorage.isTokenExpired).mockReturnValue(true);
+      vi.mocked(MCPOAuthTokenStorage.removeToken).mockResolvedValue(undefined);
+
+      mockFetch.mockResolvedValueOnce(
+        createMockResponse({
+          ok: false,
+          status: 400,
+          contentType: 'application/x-www-form-urlencoded',
+          text: 'error=invalid_request&error_description=Invalid refresh token',
+        }),
+      );
+
+      const result = await MCPOAuthProvider.getValidToken(
+        'test-server',
+        mockConfig,
+      );
+
+      expect(result).toBeNull();
+      expect(MCPOAuthTokenStorage.removeToken).toHaveBeenCalledWith(
+        'test-server',
+      );
+      expect(console.error).toHaveBeenCalledWith(
+        expect.stringContaining('Failed to refresh token'),
+      );
+    });
+
+    it('should return null for token without refresh capability', async () => {
+      const tokenWithoutRefresh = {
+        serverName: 'test-server',
+        token: {
+          ...mockToken,
+          refreshToken: undefined,
+          expiresAt: Date.now() - 3600000,
+        },
+        clientId: 'test-client-id',
+        tokenUrl: 'https://auth.example.com/token',
+        updatedAt: Date.now(),
+      };
+
+      vi.mocked(MCPOAuthTokenStorage.getToken).mockResolvedValue(
+        tokenWithoutRefresh,
+      );
+      vi.mocked(MCPOAuthTokenStorage.isTokenExpired).mockReturnValue(true);
+
+      const result = await MCPOAuthProvider.getValidToken(
+        'test-server',
+        mockConfig,
+      );
+
+      expect(result).toBeNull();
+    });
+  });
+
+  describe('PKCE parameter generation', () => {
+    it('should generate valid PKCE parameters', async () => {
+      // Test is implicit in the authenticate flow tests, but we can verify
+      // the crypto mocks are called correctly
+      let callbackHandler: unknown;
+      vi.mocked(http.createServer).mockImplementation((handler) => {
+        callbackHandler = handler;
+        return mockHttpServer as unknown as http.Server;
+      });
+
+      mockHttpServer.listen.mockImplementation((port, callback) => {
+        callback?.();
+        setTimeout(() => {
+          const mockReq = {
+            url: '/oauth/callback?code=auth_code_123&state=bW9ja19zdGF0ZV8xNl9ieXRlcw',
+          };
+          const mockRes = {
+            writeHead: vi.fn(),
+            end: vi.fn(),
+          };
+          (callbackHandler as (req: unknown, res: unknown) => void)(
+            mockReq,
+            mockRes,
+          );
+        }, 10);
+      });
+
+      mockFetch.mockResolvedValueOnce(
+        createMockResponse({
+          ok: true,
+          contentType: 'application/json',
+          text: JSON.stringify(mockTokenResponse),
+          json: mockTokenResponse,
+        }),
+      );
+
+      await MCPOAuthProvider.authenticate('test-server', mockConfig);
+
+      expect(crypto.randomBytes).toHaveBeenCalledWith(32); // code verifier
+      expect(crypto.randomBytes).toHaveBeenCalledWith(16); // state
+      expect(crypto.createHash).toHaveBeenCalledWith('sha256');
+    });
+  });
+
+  describe('Authorization URL building', () => {
+    it('should build correct authorization URL with all parameters', async () => {
+      // Mock to capture the URL that would be opened
+      let capturedUrl: string | undefined;
+      mockOpenBrowserSecurely.mockImplementation((url: string) => {
+        capturedUrl = url;
+        return Promise.resolve();
+      });
+
+      let callbackHandler: unknown;
+      vi.mocked(http.createServer).mockImplementation((handler) => {
+        callbackHandler = handler;
+        return mockHttpServer as unknown as http.Server;
+      });
+
+      mockHttpServer.listen.mockImplementation((port, callback) => {
+        callback?.();
+        setTimeout(() => {
+          const mockReq = {
+            url: '/oauth/callback?code=auth_code_123&state=bW9ja19zdGF0ZV8xNl9ieXRlcw',
+          };
+          const mockRes = {
+            writeHead: vi.fn(),
+            end: vi.fn(),
+          };
+          (callbackHandler as (req: unknown, res: unknown) => void)(
+            mockReq,
+            mockRes,
+          );
+        }, 10);
+      });
+
+      mockFetch.mockResolvedValueOnce(
+        createMockResponse({
+          ok: true,
+          contentType: 'application/json',
+          text: JSON.stringify(mockTokenResponse),
+          json: mockTokenResponse,
+        }),
+      );
+
+      await MCPOAuthProvider.authenticate(
+        'test-server',
+        mockConfig,
+        'https://auth.example.com',
+      );
+
+      expect(capturedUrl).toBeDefined();
+      expect(capturedUrl!).toContain('response_type=code');
+      expect(capturedUrl!).toContain('client_id=test-client-id');
+      expect(capturedUrl!).toContain('code_challenge=code_challenge_mock');
+      expect(capturedUrl!).toContain('code_challenge_method=S256');
+      expect(capturedUrl!).toContain('scope=read+write');
+      expect(capturedUrl!).toContain('resource=https%3A%2F%2Fauth.example.com');
+      expect(capturedUrl!).toContain('audience=https%3A%2F%2Fapi.example.com');
+    });
+
+    it('should correctly append parameters to an authorization URL that already has query params', async () => {
+      // Mock to capture the URL that would be opened
+      let capturedUrl: string;
+      mockOpenBrowserSecurely.mockImplementation((url: string) => {
+        capturedUrl = url;
+        return Promise.resolve();
+      });
+
+      let callbackHandler: unknown;
+      vi.mocked(http.createServer).mockImplementation((handler) => {
+        callbackHandler = handler;
+        return mockHttpServer as unknown as http.Server;
+      });
+
+      mockHttpServer.listen.mockImplementation((port, callback) => {
+        callback?.();
+        setTimeout(() => {
+          const mockReq = {
+            url: '/oauth/callback?code=auth_code_123&state=bW9ja19zdGF0ZV8xNl9ieXRlcw',
+          };
+          const mockRes = {
+            writeHead: vi.fn(),
+            end: vi.fn(),
+          };
+          (callbackHandler as (req: unknown, res: unknown) => void)(
+            mockReq,
+            mockRes,
+          );
+        }, 10);
+      });
+
+      mockFetch.mockResolvedValueOnce(
+        createMockResponse({
+          ok: true,
+          contentType: 'application/json',
+          text: JSON.stringify(mockTokenResponse),
+          json: mockTokenResponse,
+        }),
+      );
+
+      const configWithParamsInUrl = {
+        ...mockConfig,
+        authorizationUrl: 'https://auth.example.com/authorize?audience=1234',
+      };
+
+      await MCPOAuthProvider.authenticate('test-server', configWithParamsInUrl);
+
+      const url = new URL(capturedUrl!);
+      expect(url.searchParams.get('audience')).toBe('1234');
+      expect(url.searchParams.get('client_id')).toBe('test-client-id');
+      expect(url.search.startsWith('?audience=1234&')).toBe(true);
+    });
+
+    it('should correctly append parameters to a URL with a fragment', async () => {
+      // Mock to capture the URL that would be opened
+      let capturedUrl: string;
+      mockOpenBrowserSecurely.mockImplementation((url: string) => {
+        capturedUrl = url;
+        return Promise.resolve();
+      });
+
+      let callbackHandler: unknown;
+      vi.mocked(http.createServer).mockImplementation((handler) => {
+        callbackHandler = handler;
+        return mockHttpServer as unknown as http.Server;
+      });
+
+      mockHttpServer.listen.mockImplementation((port, callback) => {
+        callback?.();
+        setTimeout(() => {
+          const mockReq = {
+            url: '/oauth/callback?code=auth_code_123&state=bW9ja19zdGF0ZV8xNl9ieXRlcw',
+          };
+          const mockRes = {
+            writeHead: vi.fn(),
+            end: vi.fn(),
+          };
+          (callbackHandler as (req: unknown, res: unknown) => void)(
+            mockReq,
+            mockRes,
+          );
+        }, 10);
+      });
+
+      mockFetch.mockResolvedValueOnce(
+        createMockResponse({
+          ok: true,
+          contentType: 'application/json',
+          text: JSON.stringify(mockTokenResponse),
+          json: mockTokenResponse,
+        }),
+      );
+
+      const configWithFragment = {
+        ...mockConfig,
+        authorizationUrl: 'https://auth.example.com/authorize#login',
+      };
+
+      await MCPOAuthProvider.authenticate('test-server', configWithFragment);
+
+      const url = new URL(capturedUrl!);
+      expect(url.searchParams.get('client_id')).toBe('test-client-id');
+      expect(url.hash).toBe('#login');
+      expect(url.pathname).toBe('/authorize');
+    });
+  });
+});

projects/ui/qwen-code/packages/core/src/mcp/oauth-provider.ts

@@ -0,0 +1,894 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import * as http from 'node:http';
+import * as crypto from 'node:crypto';
+import { URL } from 'node:url';
+import { openBrowserSecurely } from '../utils/secure-browser-launcher.js';
+import { MCPOAuthToken, MCPOAuthTokenStorage } from './oauth-token-storage.js';
+import { getErrorMessage } from '../utils/errors.js';
+import { OAuthUtils } from './oauth-utils.js';
+
+/**
+ * OAuth configuration for an MCP server.
+ */
+export interface MCPOAuthConfig {
+  enabled?: boolean; // Whether OAuth is enabled for this server
+  clientId?: string;
+  clientSecret?: string;
+  authorizationUrl?: string;
+  tokenUrl?: string;
+  scopes?: string[];
+  audiences?: string[];
+  redirectUri?: string;
+  tokenParamName?: string; // For SSE connections, specifies the query parameter name for the token
+}
+
+/**
+ * OAuth authorization response.
+ */
+export interface OAuthAuthorizationResponse {
+  code: string;
+  state: string;
+}
+
+/**
+ * OAuth token response from the authorization server.
+ */
+export interface OAuthTokenResponse {
+  access_token: string;
+  token_type: string;
+  expires_in?: number;
+  refresh_token?: string;
+  scope?: string;
+}
+
+/**
+ * Dynamic client registration request.
+ */
+export interface OAuthClientRegistrationRequest {
+  client_name: string;
+  redirect_uris: string[];
+  grant_types: string[];
+  response_types: string[];
+  token_endpoint_auth_method: string;
+  code_challenge_method?: string[];
+  scope?: string;
+}
+
+/**
+ * Dynamic client registration response.
+ */
+export interface OAuthClientRegistrationResponse {
+  client_id: string;
+  client_secret?: string;
+  client_id_issued_at?: number;
+  client_secret_expires_at?: number;
+  redirect_uris: string[];
+  grant_types: string[];
+  response_types: string[];
+  token_endpoint_auth_method: string;
+  code_challenge_method?: string[];
+  scope?: string;
+}
+
+/**
+ * PKCE (Proof Key for Code Exchange) parameters.
+ */
+interface PKCEParams {
+  codeVerifier: string;
+  codeChallenge: string;
+  state: string;
+}
+
+/**
+ * Provider for handling OAuth authentication for MCP servers.
+ */
+export class MCPOAuthProvider {
+  private static readonly REDIRECT_PORT = 7777;
+  private static readonly REDIRECT_PATH = '/oauth/callback';
+  private static readonly HTTP_OK = 200;
+
+  /**
+   * Register a client dynamically with the OAuth server.
+   *
+   * @param registrationUrl The client registration endpoint URL
+   * @param config OAuth configuration
+   * @returns The registered client information
+   */
+  private static async registerClient(
+    registrationUrl: string,
+    config: MCPOAuthConfig,
+  ): Promise<OAuthClientRegistrationResponse> {
+    const redirectUri =
+      config.redirectUri ||
+      `http://localhost:${this.REDIRECT_PORT}${this.REDIRECT_PATH}`;
+
+    const registrationRequest: OAuthClientRegistrationRequest = {
+      client_name: 'Gemini CLI (Google ADC)',
+      redirect_uris: [redirectUri],
+      grant_types: ['authorization_code', 'refresh_token'],
+      response_types: ['code'],
+      token_endpoint_auth_method: 'none', // Public client
+      code_challenge_method: ['S256'],
+      scope: config.scopes?.join(' ') || '',
+    };
+
+    const response = await fetch(registrationUrl, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify(registrationRequest),
+    });
+
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new Error(
+        `Client registration failed: ${response.status} ${response.statusText} - ${errorText}`,
+      );
+    }
+
+    return (await response.json()) as OAuthClientRegistrationResponse;
+  }
+
+  /**
+   * Discover OAuth configuration from an MCP server URL.
+   *
+   * @param mcpServerUrl The MCP server URL
+   * @returns OAuth configuration if discovered, null otherwise
+   */
+  private static async discoverOAuthFromMCPServer(
+    mcpServerUrl: string,
+  ): Promise<MCPOAuthConfig | null> {
+    // Use the full URL with path preserved for OAuth discovery
+    return OAuthUtils.discoverOAuthConfig(mcpServerUrl);
+  }
+
+  /**
+   * Generate PKCE parameters for OAuth flow.
+   *
+   * @returns PKCE parameters including code verifier, challenge, and state
+   */
+  private static generatePKCEParams(): PKCEParams {
+    // Generate code verifier (43-128 characters)
+    const codeVerifier = crypto.randomBytes(32).toString('base64url');
+
+    // Generate code challenge using SHA256
+    const codeChallenge = crypto
+      .createHash('sha256')
+      .update(codeVerifier)
+      .digest('base64url');
+
+    // Generate state for CSRF protection
+    const state = crypto.randomBytes(16).toString('base64url');
+
+    return { codeVerifier, codeChallenge, state };
+  }
+
+  /**
+   * Start a local HTTP server to handle OAuth callback.
+   *
+   * @param expectedState The state parameter to validate
+   * @returns Promise that resolves with the authorization code
+   */
+  private static async startCallbackServer(
+    expectedState: string,
+  ): Promise<OAuthAuthorizationResponse> {
+    return new Promise((resolve, reject) => {
+      const server = http.createServer(
+        async (req: http.IncomingMessage, res: http.ServerResponse) => {
+          try {
+            const url = new URL(
+              req.url!,
+              `http://localhost:${this.REDIRECT_PORT}`,
+            );
+
+            if (url.pathname !== this.REDIRECT_PATH) {
+              res.writeHead(404);
+              res.end('Not found');
+              return;
+            }
+
+            const code = url.searchParams.get('code');
+            const state = url.searchParams.get('state');
+            const error = url.searchParams.get('error');
+
+            if (error) {
+              res.writeHead(this.HTTP_OK, { 'Content-Type': 'text/html' });
+              res.end(`
+              <html>
+                <body>
+                  <h1>Authentication Failed</h1>
+                  <p>Error: ${(error as string).replace(/</g, '&lt;').replace(/>/g, '&gt;')}</p>
+                  <p>${((url.searchParams.get('error_description') || '') as string).replace(/</g, '&lt;').replace(/>/g, '&gt;')}</p>
+                  <p>You can close this window.</p>
+                </body>
+              </html>
+            `);
+              server.close();
+              reject(new Error(`OAuth error: ${error}`));
+              return;
+            }
+
+            if (!code || !state) {
+              res.writeHead(400);
+              res.end('Missing code or state parameter');
+              return;
+            }
+
+            if (state !== expectedState) {
+              res.writeHead(400);
+              res.end('Invalid state parameter');
+              server.close();
+              reject(new Error('State mismatch - possible CSRF attack'));
+              return;
+            }
+
+            // Send success response to browser
+            res.writeHead(this.HTTP_OK, { 'Content-Type': 'text/html' });
+            res.end(`
+            <html>
+              <body>
+                <h1>Authentication Successful!</h1>
+                <p>You can close this window and return to Gemini CLI.</p>
+                <script>window.close();</script>
+              </body>
+            </html>
+          `);
+
+            server.close();
+            resolve({ code, state });
+          } catch (error) {
+            server.close();
+            reject(error);
+          }
+        },
+      );
+
+      server.on('error', reject);
+      server.listen(this.REDIRECT_PORT, () => {
+        console.log(
+          `OAuth callback server listening on port ${this.REDIRECT_PORT}`,
+        );
+      });
+
+      // Timeout after 5 minutes
+      setTimeout(
+        () => {
+          server.close();
+          reject(new Error('OAuth callback timeout'));
+        },
+        5 * 60 * 1000,
+      );
+    });
+  }
+
+  /**
+   * Build the authorization URL with PKCE parameters.
+   *
+   * @param config OAuth configuration
+   * @param pkceParams PKCE parameters
+   * @param mcpServerUrl The MCP server URL to use as the resource parameter
+   * @returns The authorization URL
+   */
+  private static buildAuthorizationUrl(
+    config: MCPOAuthConfig,
+    pkceParams: PKCEParams,
+    mcpServerUrl?: string,
+  ): string {
+    const redirectUri =
+      config.redirectUri ||
+      `http://localhost:${this.REDIRECT_PORT}${this.REDIRECT_PATH}`;
+
+    const params = new URLSearchParams({
+      client_id: config.clientId!,
+      response_type: 'code',
+      redirect_uri: redirectUri,
+      state: pkceParams.state,
+      code_challenge: pkceParams.codeChallenge,
+      code_challenge_method: 'S256',
+    });
+
+    if (config.scopes && config.scopes.length > 0) {
+      params.append('scope', config.scopes.join(' '));
+    }
+
+    if (config.audiences && config.audiences.length > 0) {
+      params.append('audience', config.audiences.join(' '));
+    }
+
+    // Add resource parameter for MCP OAuth spec compliance
+    // Only add if we have an MCP server URL (indicates MCP OAuth flow, not standard OAuth)
+    if (mcpServerUrl) {
+      try {
+        params.append(
+          'resource',
+          OAuthUtils.buildResourceParameter(mcpServerUrl),
+        );
+      } catch (error) {
+        console.warn(
+          `Could not add resource parameter: ${getErrorMessage(error)}`,
+        );
+      }
+    }
+
+    const url = new URL(config.authorizationUrl!);
+    params.forEach((value, key) => {
+      url.searchParams.append(key, value);
+    });
+    return url.toString();
+  }
+
+  /**
+   * Exchange authorization code for tokens.
+   *
+   * @param config OAuth configuration
+   * @param code Authorization code
+   * @param codeVerifier PKCE code verifier
+   * @param mcpServerUrl The MCP server URL to use as the resource parameter
+   * @returns The token response
+   */
+  private static async exchangeCodeForToken(
+    config: MCPOAuthConfig,
+    code: string,
+    codeVerifier: string,
+    mcpServerUrl?: string,
+  ): Promise<OAuthTokenResponse> {
+    const redirectUri =
+      config.redirectUri ||
+      `http://localhost:${this.REDIRECT_PORT}${this.REDIRECT_PATH}`;
+
+    const params = new URLSearchParams({
+      grant_type: 'authorization_code',
+      code,
+      redirect_uri: redirectUri,
+      code_verifier: codeVerifier,
+      client_id: config.clientId!,
+    });
+
+    if (config.clientSecret) {
+      params.append('client_secret', config.clientSecret);
+    }
+
+    if (config.audiences && config.audiences.length > 0) {
+      params.append('audience', config.audiences.join(' '));
+    }
+
+    // Add resource parameter for MCP OAuth spec compliance
+    // Only add if we have an MCP server URL (indicates MCP OAuth flow, not standard OAuth)
+    if (mcpServerUrl) {
+      const resourceUrl = mcpServerUrl;
+      try {
+        params.append(
+          'resource',
+          OAuthUtils.buildResourceParameter(resourceUrl),
+        );
+      } catch (error) {
+        console.warn(
+          `Could not add resource parameter: ${getErrorMessage(error)}`,
+        );
+      }
+    }
+
+    const response = await fetch(config.tokenUrl!, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/x-www-form-urlencoded',
+        Accept: 'application/json, application/x-www-form-urlencoded',
+      },
+      body: params.toString(),
+    });
+
+    const responseText = await response.text();
+    const contentType = response.headers.get('content-type') || '';
+
+    if (!response.ok) {
+      // Try to parse error from form-urlencoded response
+      let errorMessage: string | null = null;
+      try {
+        const errorParams = new URLSearchParams(responseText);
+        const error = errorParams.get('error');
+        const errorDescription = errorParams.get('error_description');
+        if (error) {
+          errorMessage = `Token exchange failed: ${error} - ${errorDescription || 'No description'}`;
+        }
+      } catch {
+        // Fall back to raw error
+      }
+      throw new Error(
+        errorMessage ||
+          `Token exchange failed: ${response.status} - ${responseText}`,
+      );
+    }
+
+    // Log unexpected content types for debugging
+    if (
+      !contentType.includes('application/json') &&
+      !contentType.includes('application/x-www-form-urlencoded')
+    ) {
+      console.warn(
+        `Token endpoint returned unexpected content-type: ${contentType}. ` +
+          `Expected application/json or application/x-www-form-urlencoded. ` +
+          `Will attempt to parse response.`,
+      );
+    }
+
+    // Try to parse as JSON first, fall back to form-urlencoded
+    try {
+      return JSON.parse(responseText) as OAuthTokenResponse;
+    } catch {
+      // Parse form-urlencoded response
+      const tokenParams = new URLSearchParams(responseText);
+      const accessToken = tokenParams.get('access_token');
+      const tokenType = tokenParams.get('token_type') || 'Bearer';
+      const expiresIn = tokenParams.get('expires_in');
+      const refreshToken = tokenParams.get('refresh_token');
+      const scope = tokenParams.get('scope');
+
+      if (!accessToken) {
+        // Check for error in response
+        const error = tokenParams.get('error');
+        const errorDescription = tokenParams.get('error_description');
+        throw new Error(
+          `Token exchange failed: ${error || 'no_access_token'} - ${errorDescription || responseText}`,
+        );
+      }
+
+      return {
+        access_token: accessToken,
+        token_type: tokenType,
+        expires_in: expiresIn ? parseInt(expiresIn, 10) : undefined,
+        refresh_token: refreshToken || undefined,
+        scope: scope || undefined,
+      } as OAuthTokenResponse;
+    }
+  }
+
+  /**
+   * Refresh an access token using a refresh token.
+   *
+   * @param config OAuth configuration
+   * @param refreshToken The refresh token
+   * @param tokenUrl The token endpoint URL
+   * @param mcpServerUrl The MCP server URL to use as the resource parameter
+   * @returns The new token response
+   */
+  static async refreshAccessToken(
+    config: MCPOAuthConfig,
+    refreshToken: string,
+    tokenUrl: string,
+    mcpServerUrl?: string,
+  ): Promise<OAuthTokenResponse> {
+    const params = new URLSearchParams({
+      grant_type: 'refresh_token',
+      refresh_token: refreshToken,
+      client_id: config.clientId!,
+    });
+
+    if (config.clientSecret) {
+      params.append('client_secret', config.clientSecret);
+    }
+
+    if (config.scopes && config.scopes.length > 0) {
+      params.append('scope', config.scopes.join(' '));
+    }
+
+    if (config.audiences && config.audiences.length > 0) {
+      params.append('audience', config.audiences.join(' '));
+    }
+
+    // Add resource parameter for MCP OAuth spec compliance
+    // Only add if we have an MCP server URL (indicates MCP OAuth flow, not standard OAuth)
+    if (mcpServerUrl) {
+      try {
+        params.append(
+          'resource',
+          OAuthUtils.buildResourceParameter(mcpServerUrl),
+        );
+      } catch (error) {
+        console.warn(
+          `Could not add resource parameter: ${getErrorMessage(error)}`,
+        );
+      }
+    }
+
+    const response = await fetch(tokenUrl, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/x-www-form-urlencoded',
+        Accept: 'application/json, application/x-www-form-urlencoded',
+      },
+      body: params.toString(),
+    });
+
+    const responseText = await response.text();
+    const contentType = response.headers.get('content-type') || '';
+
+    if (!response.ok) {
+      // Try to parse error from form-urlencoded response
+      let errorMessage: string | null = null;
+      try {
+        const errorParams = new URLSearchParams(responseText);
+        const error = errorParams.get('error');
+        const errorDescription = errorParams.get('error_description');
+        if (error) {
+          errorMessage = `Token refresh failed: ${error} - ${errorDescription || 'No description'}`;
+        }
+      } catch {
+        // Fall back to raw error
+      }
+      throw new Error(
+        errorMessage ||
+          `Token refresh failed: ${response.status} - ${responseText}`,
+      );
+    }
+
+    // Log unexpected content types for debugging
+    if (
+      !contentType.includes('application/json') &&
+      !contentType.includes('application/x-www-form-urlencoded')
+    ) {
+      console.warn(
+        `Token refresh endpoint returned unexpected content-type: ${contentType}. ` +
+          `Expected application/json or application/x-www-form-urlencoded. ` +
+          `Will attempt to parse response.`,
+      );
+    }
+
+    // Try to parse as JSON first, fall back to form-urlencoded
+    try {
+      return JSON.parse(responseText) as OAuthTokenResponse;
+    } catch {
+      // Parse form-urlencoded response
+      const tokenParams = new URLSearchParams(responseText);
+      const accessToken = tokenParams.get('access_token');
+      const tokenType = tokenParams.get('token_type') || 'Bearer';
+      const expiresIn = tokenParams.get('expires_in');
+      const refreshToken = tokenParams.get('refresh_token');
+      const scope = tokenParams.get('scope');
+
+      if (!accessToken) {
+        // Check for error in response
+        const error = tokenParams.get('error');
+        const errorDescription = tokenParams.get('error_description');
+        throw new Error(
+          `Token refresh failed: ${error || 'unknown_error'} - ${errorDescription || responseText}`,
+        );
+      }
+
+      return {
+        access_token: accessToken,
+        token_type: tokenType,
+        expires_in: expiresIn ? parseInt(expiresIn, 10) : undefined,
+        refresh_token: refreshToken || undefined,
+        scope: scope || undefined,
+      } as OAuthTokenResponse;
+    }
+  }
+
+  /**
+   * Perform the full OAuth authorization code flow with PKCE.
+   *
+   * @param serverName The name of the MCP server
+   * @param config OAuth configuration
+   * @param mcpServerUrl Optional MCP server URL for OAuth discovery
+   * @returns The obtained OAuth token
+   */
+  static async authenticate(
+    serverName: string,
+    config: MCPOAuthConfig,
+    mcpServerUrl?: string,
+  ): Promise<MCPOAuthToken> {
+    // If no authorization URL is provided, try to discover OAuth configuration
+    if (!config.authorizationUrl && mcpServerUrl) {
+      console.log(
+        'No authorization URL provided, attempting OAuth discovery...',
+      );
+
+      // First check if the server requires authentication via WWW-Authenticate header
+      try {
+        const headers: HeadersInit = OAuthUtils.isSSEEndpoint(mcpServerUrl)
+          ? { Accept: 'text/event-stream' }
+          : { Accept: 'application/json' };
+
+        const response = await fetch(mcpServerUrl, {
+          method: 'HEAD',
+          headers,
+        });
+
+        if (response.status === 401 || response.status === 307) {
+          const wwwAuthenticate = response.headers.get('www-authenticate');
+
+          if (wwwAuthenticate) {
+            const discoveredConfig =
+              await OAuthUtils.discoverOAuthFromWWWAuthenticate(
+                wwwAuthenticate,
+              );
+            if (discoveredConfig) {
+              // Merge discovered config with existing config, preserving clientId and clientSecret
+              config = {
+                ...config,
+                authorizationUrl: discoveredConfig.authorizationUrl,
+                tokenUrl: discoveredConfig.tokenUrl,
+                scopes: discoveredConfig.scopes || config.scopes || [],
+                // Preserve existing client credentials
+                clientId: config.clientId,
+                clientSecret: config.clientSecret,
+              };
+            }
+          }
+        }
+      } catch (error) {
+        console.debug(
+          `Failed to check endpoint for authentication requirements: ${getErrorMessage(error)}`,
+        );
+      }
+
+      // If we still don't have OAuth config, try the standard discovery
+      if (!config.authorizationUrl) {
+        const discoveredConfig =
+          await this.discoverOAuthFromMCPServer(mcpServerUrl);
+        if (discoveredConfig) {
+          // Merge discovered config with existing config, preserving clientId and clientSecret
+          config = {
+            ...config,
+            authorizationUrl: discoveredConfig.authorizationUrl,
+            tokenUrl: discoveredConfig.tokenUrl,
+            scopes: discoveredConfig.scopes || config.scopes || [],
+            // Preserve existing client credentials
+            clientId: config.clientId,
+            clientSecret: config.clientSecret,
+          };
+        } else {
+          throw new Error(
+            'Failed to discover OAuth configuration from MCP server',
+          );
+        }
+      }
+    }
+
+    // If no client ID is provided, try dynamic client registration
+    if (!config.clientId) {
+      // Extract server URL from authorization URL
+      if (!config.authorizationUrl) {
+        throw new Error(
+          'Cannot perform dynamic registration without authorization URL',
+        );
+      }
+
+      const authUrl = new URL(config.authorizationUrl);
+      const serverUrl = `${authUrl.protocol}//${authUrl.host}`;
+
+      console.log(
+        'No client ID provided, attempting dynamic client registration...',
+      );
+
+      // Get the authorization server metadata for registration
+      const authServerMetadataUrl = new URL(
+        '/.well-known/oauth-authorization-server',
+        serverUrl,
+      ).toString();
+
+      const authServerMetadata =
+        await OAuthUtils.fetchAuthorizationServerMetadata(
+          authServerMetadataUrl,
+        );
+      if (!authServerMetadata) {
+        throw new Error(
+          'Failed to fetch authorization server metadata for client registration',
+        );
+      }
+
+      // Register client if registration endpoint is available
+      if (authServerMetadata.registration_endpoint) {
+        const clientRegistration = await this.registerClient(
+          authServerMetadata.registration_endpoint,
+          config,
+        );
+
+        config.clientId = clientRegistration.client_id;
+        if (clientRegistration.client_secret) {
+          config.clientSecret = clientRegistration.client_secret;
+        }
+
+        console.log('Dynamic client registration successful');
+      } else {
+        throw new Error(
+          'No client ID provided and dynamic registration not supported',
+        );
+      }
+    }
+
+    // Validate configuration
+    if (!config.clientId || !config.authorizationUrl || !config.tokenUrl) {
+      throw new Error(
+        'Missing required OAuth configuration after discovery and registration',
+      );
+    }
+
+    // Generate PKCE parameters
+    const pkceParams = this.generatePKCEParams();
+
+    // Build authorization URL
+    const authUrl = this.buildAuthorizationUrl(
+      config,
+      pkceParams,
+      mcpServerUrl,
+    );
+
+    console.log('\nOpening browser for OAuth authentication...');
+    console.log('If the browser does not open, please visit:');
+    console.log('');
+
+    // Get terminal width or default to 80
+    const terminalWidth = process.stdout.columns || 80;
+    const separatorLength = Math.min(terminalWidth - 2, 80);
+    const separator = '━'.repeat(separatorLength);
+
+    console.log(separator);
+    console.log(
+      'COPY THE ENTIRE URL BELOW (select all text between the lines):',
+    );
+    console.log(separator);
+    console.log(authUrl);
+    console.log(separator);
+    console.log('');
+    console.log(
+      '💡 TIP: Triple-click to select the entire URL, then copy and paste it into your browser.',
+    );
+    console.log(
+      '⚠️  Make sure to copy the COMPLETE URL - it may wrap across multiple lines.',
+    );
+    console.log('');
+
+    // Start callback server
+    const callbackPromise = this.startCallbackServer(pkceParams.state);
+
+    // Open browser securely
+    try {
+      await openBrowserSecurely(authUrl);
+    } catch (error) {
+      console.warn(
+        'Failed to open browser automatically:',
+        getErrorMessage(error),
+      );
+    }
+
+    // Wait for callback
+    const { code } = await callbackPromise;
+
+    console.log('\nAuthorization code received, exchanging for tokens...');
+
+    // Exchange code for tokens
+    const tokenResponse = await this.exchangeCodeForToken(
+      config,
+      code,
+      pkceParams.codeVerifier,
+      mcpServerUrl,
+    );
+
+    // Convert to our token format
+    if (!tokenResponse.access_token) {
+      throw new Error('No access token received from token endpoint');
+    }
+
+    const token: MCPOAuthToken = {
+      accessToken: tokenResponse.access_token,
+      tokenType: tokenResponse.token_type || 'Bearer',
+      refreshToken: tokenResponse.refresh_token,
+      scope: tokenResponse.scope,
+    };
+
+    if (tokenResponse.expires_in) {
+      token.expiresAt = Date.now() + tokenResponse.expires_in * 1000;
+    }
+
+    // Save token
+    try {
+      await MCPOAuthTokenStorage.saveToken(
+        serverName,
+        token,
+        config.clientId,
+        config.tokenUrl,
+        mcpServerUrl,
+      );
+      console.log('Authentication successful! Token saved.');
+
+      // Verify token was saved
+      const savedToken = await MCPOAuthTokenStorage.getToken(serverName);
+      if (savedToken && savedToken.token && savedToken.token.accessToken) {
+        const tokenPreview =
+          savedToken.token.accessToken.length > 20
+            ? `${savedToken.token.accessToken.substring(0, 20)}...`
+            : '[token]';
+        console.log(`Token verification successful: ${tokenPreview}`);
+      } else {
+        console.error(
+          'Token verification failed: token not found or invalid after save',
+        );
+      }
+    } catch (saveError) {
+      console.error(`Failed to save token: ${getErrorMessage(saveError)}`);
+      throw saveError;
+    }
+
+    return token;
+  }
+
+  /**
+   * Get a valid access token for an MCP server, refreshing if necessary.
+   *
+   * @param serverName The name of the MCP server
+   * @param config OAuth configuration
+   * @returns A valid access token or null if not authenticated
+   */
+  static async getValidToken(
+    serverName: string,
+    config: MCPOAuthConfig,
+  ): Promise<string | null> {
+    console.debug(`Getting valid token for server: ${serverName}`);
+    const credentials = await MCPOAuthTokenStorage.getToken(serverName);
+
+    if (!credentials) {
+      console.debug(`No credentials found for server: ${serverName}`);
+      return null;
+    }
+
+    const { token } = credentials;
+    console.debug(
+      `Found token for server: ${serverName}, expired: ${MCPOAuthTokenStorage.isTokenExpired(token)}`,
+    );
+
+    // Check if token is expired
+    if (!MCPOAuthTokenStorage.isTokenExpired(token)) {
+      console.debug(`Returning valid token for server: ${serverName}`);
+      return token.accessToken;
+    }
+
+    // Try to refresh if we have a refresh token
+    if (token.refreshToken && config.clientId && credentials.tokenUrl) {
+      try {
+        console.log(`Refreshing expired token for MCP server: ${serverName}`);
+
+        const newTokenResponse = await this.refreshAccessToken(
+          config,
+          token.refreshToken,
+          credentials.tokenUrl,
+          credentials.mcpServerUrl,
+        );
+
+        // Update stored token
+        const newToken: MCPOAuthToken = {
+          accessToken: newTokenResponse.access_token,
+          tokenType: newTokenResponse.token_type,
+          refreshToken: newTokenResponse.refresh_token || token.refreshToken,
+          scope: newTokenResponse.scope || token.scope,
+        };
+
+        if (newTokenResponse.expires_in) {
+          newToken.expiresAt = Date.now() + newTokenResponse.expires_in * 1000;
+        }
+
+        await MCPOAuthTokenStorage.saveToken(
+          serverName,
+          newToken,
+          config.clientId,
+          credentials.tokenUrl,
+          credentials.mcpServerUrl,
+        );
+
+        return newToken.accessToken;
+      } catch (error) {
+        console.error(`Failed to refresh token: ${getErrorMessage(error)}`);
+        // Remove invalid token
+        await MCPOAuthTokenStorage.removeToken(serverName);
+      }
+    }
+
+    return null;
+  }
+}

projects/ui/qwen-code/packages/core/src/mcp/oauth-token-storage.test.ts

@@ -0,0 +1,325 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { promises as fs } from 'node:fs';
+import * as path from 'node:path';
+import {
+  MCPOAuthTokenStorage,
+  MCPOAuthToken,
+  MCPOAuthCredentials,
+} from './oauth-token-storage.js';
+
+// Mock file system operations
+vi.mock('node:fs', () => ({
+  promises: {
+    readFile: vi.fn(),
+    writeFile: vi.fn(),
+    mkdir: vi.fn(),
+    unlink: vi.fn(),
+  },
+}));
+
+vi.mock('node:os', () => ({
+  homedir: vi.fn(() => '/mock/home'),
+}));
+
+describe('MCPOAuthTokenStorage', () => {
+  const mockToken: MCPOAuthToken = {
+    accessToken: 'access_token_123',
+    refreshToken: 'refresh_token_456',
+    tokenType: 'Bearer',
+    scope: 'read write',
+    expiresAt: Date.now() + 3600000, // 1 hour from now
+  };
+
+  const mockCredentials: MCPOAuthCredentials = {
+    serverName: 'test-server',
+    token: mockToken,
+    clientId: 'test-client-id',
+    tokenUrl: 'https://auth.example.com/token',
+    updatedAt: Date.now(),
+  };
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    vi.spyOn(console, 'error').mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  describe('loadTokens', () => {
+    it('should return empty map when token file does not exist', async () => {
+      vi.mocked(fs.readFile).mockRejectedValue({ code: 'ENOENT' });
+
+      const tokens = await MCPOAuthTokenStorage.loadTokens();
+
+      expect(tokens.size).toBe(0);
+      expect(console.error).not.toHaveBeenCalled();
+    });
+
+    it('should load tokens from file successfully', async () => {
+      const tokensArray = [mockCredentials];
+      vi.mocked(fs.readFile).mockResolvedValue(JSON.stringify(tokensArray));
+
+      const tokens = await MCPOAuthTokenStorage.loadTokens();
+
+      expect(tokens.size).toBe(1);
+      expect(tokens.get('test-server')).toEqual(mockCredentials);
+      expect(fs.readFile).toHaveBeenCalledWith(
+        path.join('/mock/home', '.gemini', 'mcp-oauth-tokens.json'),
+        'utf-8',
+      );
+    });
+
+    it('should handle corrupted token file gracefully', async () => {
+      vi.mocked(fs.readFile).mockResolvedValue('invalid json');
+
+      const tokens = await MCPOAuthTokenStorage.loadTokens();
+
+      expect(tokens.size).toBe(0);
+      expect(console.error).toHaveBeenCalledWith(
+        expect.stringContaining('Failed to load MCP OAuth tokens'),
+      );
+    });
+
+    it('should handle file read errors other than ENOENT', async () => {
+      const error = new Error('Permission denied');
+      vi.mocked(fs.readFile).mockRejectedValue(error);
+
+      const tokens = await MCPOAuthTokenStorage.loadTokens();
+
+      expect(tokens.size).toBe(0);
+      expect(console.error).toHaveBeenCalledWith(
+        expect.stringContaining('Failed to load MCP OAuth tokens'),
+      );
+    });
+  });
+
+  describe('saveToken', () => {
+    it('should save token with restricted permissions', async () => {
+      vi.mocked(fs.readFile).mockRejectedValue({ code: 'ENOENT' });
+      vi.mocked(fs.mkdir).mockResolvedValue(undefined);
+      vi.mocked(fs.writeFile).mockResolvedValue(undefined);
+
+      await MCPOAuthTokenStorage.saveToken(
+        'test-server',
+        mockToken,
+        'client-id',
+        'https://token.url',
+      );
+
+      expect(fs.mkdir).toHaveBeenCalledWith(
+        path.join('/mock/home', '.gemini'),
+        { recursive: true },
+      );
+      expect(fs.writeFile).toHaveBeenCalledWith(
+        path.join('/mock/home', '.gemini', 'mcp-oauth-tokens.json'),
+        expect.stringContaining('test-server'),
+        { mode: 0o600 },
+      );
+    });
+
+    it('should update existing token for same server', async () => {
+      const existingCredentials = {
+        ...mockCredentials,
+        serverName: 'existing-server',
+      };
+      vi.mocked(fs.readFile).mockResolvedValue(
+        JSON.stringify([existingCredentials]),
+      );
+      vi.mocked(fs.writeFile).mockResolvedValue(undefined);
+
+      const newToken = { ...mockToken, accessToken: 'new_access_token' };
+      await MCPOAuthTokenStorage.saveToken('existing-server', newToken);
+
+      const writeCall = vi.mocked(fs.writeFile).mock.calls[0];
+      const savedData = JSON.parse(writeCall[1] as string);
+
+      expect(savedData).toHaveLength(1);
+      expect(savedData[0].token.accessToken).toBe('new_access_token');
+      expect(savedData[0].serverName).toBe('existing-server');
+    });
+
+    it('should handle write errors gracefully', async () => {
+      vi.mocked(fs.readFile).mockRejectedValue({ code: 'ENOENT' });
+      vi.mocked(fs.mkdir).mockResolvedValue(undefined);
+      const writeError = new Error('Disk full');
+      vi.mocked(fs.writeFile).mockRejectedValue(writeError);
+
+      await expect(
+        MCPOAuthTokenStorage.saveToken('test-server', mockToken),
+      ).rejects.toThrow('Disk full');
+
+      expect(console.error).toHaveBeenCalledWith(
+        expect.stringContaining('Failed to save MCP OAuth token'),
+      );
+    });
+  });
+
+  describe('getToken', () => {
+    it('should return token for existing server', async () => {
+      vi.mocked(fs.readFile).mockResolvedValue(
+        JSON.stringify([mockCredentials]),
+      );
+
+      const result = await MCPOAuthTokenStorage.getToken('test-server');
+
+      expect(result).toEqual(mockCredentials);
+    });
+
+    it('should return null for non-existent server', async () => {
+      vi.mocked(fs.readFile).mockResolvedValue(
+        JSON.stringify([mockCredentials]),
+      );
+
+      const result = await MCPOAuthTokenStorage.getToken('non-existent');
+
+      expect(result).toBeNull();
+    });
+
+    it('should return null when no tokens file exists', async () => {
+      vi.mocked(fs.readFile).mockRejectedValue({ code: 'ENOENT' });
+
+      const result = await MCPOAuthTokenStorage.getToken('test-server');
+
+      expect(result).toBeNull();
+    });
+  });
+
+  describe('removeToken', () => {
+    it('should remove token for specific server', async () => {
+      const credentials1 = { ...mockCredentials, serverName: 'server1' };
+      const credentials2 = { ...mockCredentials, serverName: 'server2' };
+      vi.mocked(fs.readFile).mockResolvedValue(
+        JSON.stringify([credentials1, credentials2]),
+      );
+      vi.mocked(fs.writeFile).mockResolvedValue(undefined);
+
+      await MCPOAuthTokenStorage.removeToken('server1');
+
+      const writeCall = vi.mocked(fs.writeFile).mock.calls[0];
+      const savedData = JSON.parse(writeCall[1] as string);
+
+      expect(savedData).toHaveLength(1);
+      expect(savedData[0].serverName).toBe('server2');
+    });
+
+    it('should remove token file when no tokens remain', async () => {
+      vi.mocked(fs.readFile).mockResolvedValue(
+        JSON.stringify([mockCredentials]),
+      );
+      vi.mocked(fs.unlink).mockResolvedValue(undefined);
+
+      await MCPOAuthTokenStorage.removeToken('test-server');
+
+      expect(fs.unlink).toHaveBeenCalledWith(
+        path.join('/mock/home', '.gemini', 'mcp-oauth-tokens.json'),
+      );
+      expect(fs.writeFile).not.toHaveBeenCalled();
+    });
+
+    it('should handle removal of non-existent token gracefully', async () => {
+      vi.mocked(fs.readFile).mockResolvedValue(
+        JSON.stringify([mockCredentials]),
+      );
+
+      await MCPOAuthTokenStorage.removeToken('non-existent');
+
+      expect(fs.writeFile).not.toHaveBeenCalled();
+      expect(fs.unlink).not.toHaveBeenCalled();
+    });
+
+    it('should handle file operation errors gracefully', async () => {
+      vi.mocked(fs.readFile).mockResolvedValue(
+        JSON.stringify([mockCredentials]),
+      );
+      vi.mocked(fs.unlink).mockRejectedValue(new Error('Permission denied'));
+
+      await MCPOAuthTokenStorage.removeToken('test-server');
+
+      expect(console.error).toHaveBeenCalledWith(
+        expect.stringContaining('Failed to remove MCP OAuth token'),
+      );
+    });
+  });
+
+  describe('isTokenExpired', () => {
+    it('should return false for token without expiry', () => {
+      const tokenWithoutExpiry = { ...mockToken };
+      delete tokenWithoutExpiry.expiresAt;
+
+      const result = MCPOAuthTokenStorage.isTokenExpired(tokenWithoutExpiry);
+
+      expect(result).toBe(false);
+    });
+
+    it('should return false for valid token', () => {
+      const futureToken = {
+        ...mockToken,
+        expiresAt: Date.now() + 3600000, // 1 hour from now
+      };
+
+      const result = MCPOAuthTokenStorage.isTokenExpired(futureToken);
+
+      expect(result).toBe(false);
+    });
+
+    it('should return true for expired token', () => {
+      const expiredToken = {
+        ...mockToken,
+        expiresAt: Date.now() - 3600000, // 1 hour ago
+      };
+
+      const result = MCPOAuthTokenStorage.isTokenExpired(expiredToken);
+
+      expect(result).toBe(true);
+    });
+
+    it('should return true for token expiring within buffer time', () => {
+      const soonToExpireToken = {
+        ...mockToken,
+        expiresAt: Date.now() + 60000, // 1 minute from now (within 5-minute buffer)
+      };
+
+      const result = MCPOAuthTokenStorage.isTokenExpired(soonToExpireToken);
+
+      expect(result).toBe(true);
+    });
+  });
+
+  describe('clearAllTokens', () => {
+    it('should remove token file successfully', async () => {
+      vi.mocked(fs.unlink).mockResolvedValue(undefined);
+
+      await MCPOAuthTokenStorage.clearAllTokens();
+
+      expect(fs.unlink).toHaveBeenCalledWith(
+        path.join('/mock/home', '.gemini', 'mcp-oauth-tokens.json'),
+      );
+    });
+
+    it('should handle non-existent file gracefully', async () => {
+      vi.mocked(fs.unlink).mockRejectedValue({ code: 'ENOENT' });
+
+      await MCPOAuthTokenStorage.clearAllTokens();
+
+      expect(console.error).not.toHaveBeenCalled();
+    });
+
+    it('should handle other file errors gracefully', async () => {
+      vi.mocked(fs.unlink).mockRejectedValue(new Error('Permission denied'));
+
+      await MCPOAuthTokenStorage.clearAllTokens();
+
+      expect(console.error).toHaveBeenCalledWith(
+        expect.stringContaining('Failed to clear MCP OAuth tokens'),
+      );
+    });
+  });
+});

projects/ui/qwen-code/packages/core/src/mcp/oauth-token-storage.ts

@@ -0,0 +1,209 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { promises as fs } from 'node:fs';
+import * as path from 'node:path';
+import * as os from 'node:os';
+import { getErrorMessage } from '../utils/errors.js';
+
+/**
+ * Interface for MCP OAuth tokens.
+ */
+export interface MCPOAuthToken {
+  accessToken: string;
+  refreshToken?: string;
+  expiresAt?: number;
+  tokenType: string;
+  scope?: string;
+}
+
+/**
+ * Interface for stored MCP OAuth credentials.
+ */
+export interface MCPOAuthCredentials {
+  serverName: string;
+  token: MCPOAuthToken;
+  clientId?: string;
+  tokenUrl?: string;
+  mcpServerUrl?: string;
+  updatedAt: number;
+}
+
+/**
+ * Class for managing MCP OAuth token storage and retrieval.
+ */
+export class MCPOAuthTokenStorage {
+  private static readonly TOKEN_FILE = 'mcp-oauth-tokens.json';
+  private static readonly CONFIG_DIR = '.gemini';
+
+  /**
+   * Get the path to the token storage file.
+   *
+   * @returns The full path to the token storage file
+   */
+  private static getTokenFilePath(): string {
+    const homeDir = os.homedir();
+    return path.join(homeDir, this.CONFIG_DIR, this.TOKEN_FILE);
+  }
+
+  /**
+   * Ensure the config directory exists.
+   */
+  private static async ensureConfigDir(): Promise<void> {
+    const configDir = path.dirname(this.getTokenFilePath());
+    await fs.mkdir(configDir, { recursive: true });
+  }
+
+  /**
+   * Load all stored MCP OAuth tokens.
+   *
+   * @returns A map of server names to credentials
+   */
+  static async loadTokens(): Promise<Map<string, MCPOAuthCredentials>> {
+    const tokenMap = new Map<string, MCPOAuthCredentials>();
+
+    try {
+      const tokenFile = this.getTokenFilePath();
+      const data = await fs.readFile(tokenFile, 'utf-8');
+      const tokens = JSON.parse(data) as MCPOAuthCredentials[];
+
+      for (const credential of tokens) {
+        tokenMap.set(credential.serverName, credential);
+      }
+    } catch (error) {
+      // File doesn't exist or is invalid, return empty map
+      if ((error as NodeJS.ErrnoException).code !== 'ENOENT') {
+        console.error(
+          `Failed to load MCP OAuth tokens: ${getErrorMessage(error)}`,
+        );
+      }
+    }
+
+    return tokenMap;
+  }
+
+  /**
+   * Save a token for a specific MCP server.
+   *
+   * @param serverName The name of the MCP server
+   * @param token The OAuth token to save
+   * @param clientId Optional client ID used for this token
+   * @param tokenUrl Optional token URL used for this token
+   * @param mcpServerUrl Optional MCP server URL
+   */
+  static async saveToken(
+    serverName: string,
+    token: MCPOAuthToken,
+    clientId?: string,
+    tokenUrl?: string,
+    mcpServerUrl?: string,
+  ): Promise<void> {
+    await this.ensureConfigDir();
+
+    const tokens = await this.loadTokens();
+
+    const credential: MCPOAuthCredentials = {
+      serverName,
+      token,
+      clientId,
+      tokenUrl,
+      mcpServerUrl,
+      updatedAt: Date.now(),
+    };
+
+    tokens.set(serverName, credential);
+
+    const tokenArray = Array.from(tokens.values());
+    const tokenFile = this.getTokenFilePath();
+
+    try {
+      await fs.writeFile(
+        tokenFile,
+        JSON.stringify(tokenArray, null, 2),
+        { mode: 0o600 }, // Restrict file permissions
+      );
+    } catch (error) {
+      console.error(
+        `Failed to save MCP OAuth token: ${getErrorMessage(error)}`,
+      );
+      throw error;
+    }
+  }
+
+  /**
+   * Get a token for a specific MCP server.
+   *
+   * @param serverName The name of the MCP server
+   * @returns The stored credentials or null if not found
+   */
+  static async getToken(
+    serverName: string,
+  ): Promise<MCPOAuthCredentials | null> {
+    const tokens = await this.loadTokens();
+    return tokens.get(serverName) || null;
+  }
+
+  /**
+   * Remove a token for a specific MCP server.
+   *
+   * @param serverName The name of the MCP server
+   */
+  static async removeToken(serverName: string): Promise<void> {
+    const tokens = await this.loadTokens();
+
+    if (tokens.delete(serverName)) {
+      const tokenArray = Array.from(tokens.values());
+      const tokenFile = this.getTokenFilePath();
+
+      try {
+        if (tokenArray.length === 0) {
+          // Remove file if no tokens left
+          await fs.unlink(tokenFile);
+        } else {
+          await fs.writeFile(tokenFile, JSON.stringify(tokenArray, null, 2), {
+            mode: 0o600,
+          });
+        }
+      } catch (error) {
+        console.error(
+          `Failed to remove MCP OAuth token: ${getErrorMessage(error)}`,
+        );
+      }
+    }
+  }
+
+  /**
+   * Check if a token is expired.
+   *
+   * @param token The token to check
+   * @returns True if the token is expired
+   */
+  static isTokenExpired(token: MCPOAuthToken): boolean {
+    if (!token.expiresAt) {
+      return false; // No expiry, assume valid
+    }
+
+    // Add a 5-minute buffer to account for clock skew
+    const bufferMs = 5 * 60 * 1000;
+    return Date.now() + bufferMs >= token.expiresAt;
+  }
+
+  /**
+   * Clear all stored MCP OAuth tokens.
+   */
+  static async clearAllTokens(): Promise<void> {
+    try {
+      const tokenFile = this.getTokenFilePath();
+      await fs.unlink(tokenFile);
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code !== 'ENOENT') {
+        console.error(
+          `Failed to clear MCP OAuth tokens: ${getErrorMessage(error)}`,
+        );
+      }
+    }
+  }
+}

projects/ui/qwen-code/packages/core/src/mcp/oauth-utils.test.ts

@@ -0,0 +1,242 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import {
+  OAuthUtils,
+  OAuthAuthorizationServerMetadata,
+  OAuthProtectedResourceMetadata,
+} from './oauth-utils.js';
+
+// Mock fetch globally
+const mockFetch = vi.fn();
+global.fetch = mockFetch;
+
+describe('OAuthUtils', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    vi.spyOn(console, 'debug').mockImplementation(() => {});
+    vi.spyOn(console, 'error').mockImplementation(() => {});
+    vi.spyOn(console, 'log').mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  describe('buildWellKnownUrls', () => {
+    it('should build standard root-based URLs by default', () => {
+      const urls = OAuthUtils.buildWellKnownUrls('https://example.com/mcp');
+      expect(urls.protectedResource).toBe(
+        'https://example.com/.well-known/oauth-protected-resource',
+      );
+      expect(urls.authorizationServer).toBe(
+        'https://example.com/.well-known/oauth-authorization-server',
+      );
+    });
+
+    it('should build path-based URLs when includePathSuffix is true', () => {
+      const urls = OAuthUtils.buildWellKnownUrls(
+        'https://example.com/mcp',
+        true,
+      );
+      expect(urls.protectedResource).toBe(
+        'https://example.com/.well-known/oauth-protected-resource/mcp',
+      );
+      expect(urls.authorizationServer).toBe(
+        'https://example.com/.well-known/oauth-authorization-server/mcp',
+      );
+    });
+
+    it('should handle root path correctly', () => {
+      const urls = OAuthUtils.buildWellKnownUrls('https://example.com', true);
+      expect(urls.protectedResource).toBe(
+        'https://example.com/.well-known/oauth-protected-resource',
+      );
+      expect(urls.authorizationServer).toBe(
+        'https://example.com/.well-known/oauth-authorization-server',
+      );
+    });
+
+    it('should handle trailing slash in path', () => {
+      const urls = OAuthUtils.buildWellKnownUrls(
+        'https://example.com/mcp/',
+        true,
+      );
+      expect(urls.protectedResource).toBe(
+        'https://example.com/.well-known/oauth-protected-resource/mcp',
+      );
+      expect(urls.authorizationServer).toBe(
+        'https://example.com/.well-known/oauth-authorization-server/mcp',
+      );
+    });
+  });
+
+  describe('fetchProtectedResourceMetadata', () => {
+    const mockResourceMetadata: OAuthProtectedResourceMetadata = {
+      resource: 'https://api.example.com',
+      authorization_servers: ['https://auth.example.com'],
+      bearer_methods_supported: ['header'],
+    };
+
+    it('should fetch protected resource metadata successfully', async () => {
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        json: () => Promise.resolve(mockResourceMetadata),
+      });
+
+      const result = await OAuthUtils.fetchProtectedResourceMetadata(
+        'https://example.com/.well-known/oauth-protected-resource',
+      );
+
+      expect(result).toEqual(mockResourceMetadata);
+    });
+
+    it('should return null when fetch fails', async () => {
+      mockFetch.mockResolvedValueOnce({
+        ok: false,
+      });
+
+      const result = await OAuthUtils.fetchProtectedResourceMetadata(
+        'https://example.com/.well-known/oauth-protected-resource',
+      );
+
+      expect(result).toBeNull();
+    });
+  });
+
+  describe('fetchAuthorizationServerMetadata', () => {
+    const mockAuthServerMetadata: OAuthAuthorizationServerMetadata = {
+      issuer: 'https://auth.example.com',
+      authorization_endpoint: 'https://auth.example.com/authorize',
+      token_endpoint: 'https://auth.example.com/token',
+      scopes_supported: ['read', 'write'],
+    };
+
+    it('should fetch authorization server metadata successfully', async () => {
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        json: () => Promise.resolve(mockAuthServerMetadata),
+      });
+
+      const result = await OAuthUtils.fetchAuthorizationServerMetadata(
+        'https://auth.example.com/.well-known/oauth-authorization-server',
+      );
+
+      expect(result).toEqual(mockAuthServerMetadata);
+    });
+
+    it('should return null when fetch fails', async () => {
+      mockFetch.mockResolvedValueOnce({
+        ok: false,
+      });
+
+      const result = await OAuthUtils.fetchAuthorizationServerMetadata(
+        'https://auth.example.com/.well-known/oauth-authorization-server',
+      );
+
+      expect(result).toBeNull();
+    });
+  });
+
+  describe('metadataToOAuthConfig', () => {
+    it('should convert metadata to OAuth config', () => {
+      const metadata: OAuthAuthorizationServerMetadata = {
+        issuer: 'https://auth.example.com',
+        authorization_endpoint: 'https://auth.example.com/authorize',
+        token_endpoint: 'https://auth.example.com/token',
+        scopes_supported: ['read', 'write'],
+      };
+
+      const config = OAuthUtils.metadataToOAuthConfig(metadata);
+
+      expect(config).toEqual({
+        authorizationUrl: 'https://auth.example.com/authorize',
+        tokenUrl: 'https://auth.example.com/token',
+        scopes: ['read', 'write'],
+      });
+    });
+
+    it('should handle empty scopes', () => {
+      const metadata: OAuthAuthorizationServerMetadata = {
+        issuer: 'https://auth.example.com',
+        authorization_endpoint: 'https://auth.example.com/authorize',
+        token_endpoint: 'https://auth.example.com/token',
+      };
+
+      const config = OAuthUtils.metadataToOAuthConfig(metadata);
+
+      expect(config.scopes).toEqual([]);
+    });
+  });
+
+  describe('parseWWWAuthenticateHeader', () => {
+    it('should parse resource metadata URI from WWW-Authenticate header', () => {
+      const header =
+        'Bearer realm="example", resource_metadata="https://example.com/.well-known/oauth-protected-resource"';
+      const result = OAuthUtils.parseWWWAuthenticateHeader(header);
+      expect(result).toBe(
+        'https://example.com/.well-known/oauth-protected-resource',
+      );
+    });
+
+    it('should return null when no resource metadata URI is found', () => {
+      const header = 'Bearer realm="example"';
+      const result = OAuthUtils.parseWWWAuthenticateHeader(header);
+      expect(result).toBeNull();
+    });
+  });
+
+  describe('extractBaseUrl', () => {
+    it('should extract base URL from MCP server URL', () => {
+      const result = OAuthUtils.extractBaseUrl('https://example.com/mcp/v1');
+      expect(result).toBe('https://example.com');
+    });
+
+    it('should handle URLs with ports', () => {
+      const result = OAuthUtils.extractBaseUrl(
+        'https://example.com:8080/mcp/v1',
+      );
+      expect(result).toBe('https://example.com:8080');
+    });
+  });
+
+  describe('isSSEEndpoint', () => {
+    it('should return true for SSE endpoints', () => {
+      expect(OAuthUtils.isSSEEndpoint('https://example.com/sse')).toBe(true);
+      expect(OAuthUtils.isSSEEndpoint('https://example.com/api/v1/sse')).toBe(
+        true,
+      );
+    });
+
+    it('should return true for non-MCP endpoints', () => {
+      expect(OAuthUtils.isSSEEndpoint('https://example.com/api')).toBe(true);
+    });
+
+    it('should return false for MCP endpoints', () => {
+      expect(OAuthUtils.isSSEEndpoint('https://example.com/mcp')).toBe(false);
+      expect(OAuthUtils.isSSEEndpoint('https://example.com/api/mcp/v1')).toBe(
+        false,
+      );
+    });
+  });
+
+  describe('buildResourceParameter', () => {
+    it('should build resource parameter from endpoint URL', () => {
+      const result = OAuthUtils.buildResourceParameter(
+        'https://example.com/oauth/token',
+      );
+      expect(result).toBe('https://example.com');
+    });
+
+    it('should handle URLs with ports', () => {
+      const result = OAuthUtils.buildResourceParameter(
+        'https://example.com:8080/oauth/token',
+      );
+      expect(result).toBe('https://example.com:8080');
+    });
+  });
+});

projects/ui/qwen-code/packages/core/src/mcp/oauth-utils.ts

@@ -0,0 +1,347 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { MCPOAuthConfig } from './oauth-provider.js';
+import { getErrorMessage } from '../utils/errors.js';
+
+/**
+ * OAuth authorization server metadata as per RFC 8414.
+ */
+export interface OAuthAuthorizationServerMetadata {
+  issuer: string;
+  authorization_endpoint: string;
+  token_endpoint: string;
+  token_endpoint_auth_methods_supported?: string[];
+  revocation_endpoint?: string;
+  revocation_endpoint_auth_methods_supported?: string[];
+  registration_endpoint?: string;
+  response_types_supported?: string[];
+  grant_types_supported?: string[];
+  code_challenge_methods_supported?: string[];
+  scopes_supported?: string[];
+}
+
+/**
+ * OAuth protected resource metadata as per RFC 9728.
+ */
+export interface OAuthProtectedResourceMetadata {
+  resource: string;
+  authorization_servers?: string[];
+  bearer_methods_supported?: string[];
+  resource_documentation?: string;
+  resource_signing_alg_values_supported?: string[];
+  resource_encryption_alg_values_supported?: string[];
+  resource_encryption_enc_values_supported?: string[];
+}
+
+/**
+ * Utility class for common OAuth operations.
+ */
+export class OAuthUtils {
+  /**
+   * Construct well-known OAuth endpoint URLs.
+   * By default, uses standard root-based well-known URLs.
+   * If includePathSuffix is true, appends any path from the base URL to the well-known endpoints.
+   */
+  static buildWellKnownUrls(baseUrl: string, includePathSuffix = false) {
+    const serverUrl = new URL(baseUrl);
+    const base = `${serverUrl.protocol}//${serverUrl.host}`;
+
+    if (!includePathSuffix) {
+      // Standard discovery: use root-based well-known URLs
+      return {
+        protectedResource: new URL(
+          '/.well-known/oauth-protected-resource',
+          base,
+        ).toString(),
+        authorizationServer: new URL(
+          '/.well-known/oauth-authorization-server',
+          base,
+        ).toString(),
+      };
+    }
+
+    // Path-based discovery: append path suffix to well-known URLs
+    const pathSuffix = serverUrl.pathname.replace(/\/$/, ''); // Remove trailing slash
+    return {
+      protectedResource: new URL(
+        `/.well-known/oauth-protected-resource${pathSuffix}`,
+        base,
+      ).toString(),
+      authorizationServer: new URL(
+        `/.well-known/oauth-authorization-server${pathSuffix}`,
+        base,
+      ).toString(),
+    };
+  }
+
+  /**
+   * Fetch OAuth protected resource metadata.
+   *
+   * @param resourceMetadataUrl The protected resource metadata URL
+   * @returns The protected resource metadata or null if not available
+   */
+  static async fetchProtectedResourceMetadata(
+    resourceMetadataUrl: string,
+  ): Promise<OAuthProtectedResourceMetadata | null> {
+    try {
+      const response = await fetch(resourceMetadataUrl);
+      if (!response.ok) {
+        return null;
+      }
+      return (await response.json()) as OAuthProtectedResourceMetadata;
+    } catch (error) {
+      console.debug(
+        `Failed to fetch protected resource metadata from ${resourceMetadataUrl}: ${getErrorMessage(error)}`,
+      );
+      return null;
+    }
+  }
+
+  /**
+   * Fetch OAuth authorization server metadata.
+   *
+   * @param authServerMetadataUrl The authorization server metadata URL
+   * @returns The authorization server metadata or null if not available
+   */
+  static async fetchAuthorizationServerMetadata(
+    authServerMetadataUrl: string,
+  ): Promise<OAuthAuthorizationServerMetadata | null> {
+    try {
+      const response = await fetch(authServerMetadataUrl);
+      if (!response.ok) {
+        return null;
+      }
+      return (await response.json()) as OAuthAuthorizationServerMetadata;
+    } catch (error) {
+      console.debug(
+        `Failed to fetch authorization server metadata from ${authServerMetadataUrl}: ${getErrorMessage(error)}`,
+      );
+      return null;
+    }
+  }
+
+  /**
+   * Convert authorization server metadata to OAuth configuration.
+   *
+   * @param metadata The authorization server metadata
+   * @returns The OAuth configuration
+   */
+  static metadataToOAuthConfig(
+    metadata: OAuthAuthorizationServerMetadata,
+  ): MCPOAuthConfig {
+    return {
+      authorizationUrl: metadata.authorization_endpoint,
+      tokenUrl: metadata.token_endpoint,
+      scopes: metadata.scopes_supported || [],
+    };
+  }
+
+  /**
+   * Discover OAuth configuration using the standard well-known endpoints.
+   *
+   * @param serverUrl The base URL of the server
+   * @returns The discovered OAuth configuration or null if not available
+   */
+  static async discoverOAuthConfig(
+    serverUrl: string,
+  ): Promise<MCPOAuthConfig | null> {
+    try {
+      // First try standard root-based discovery
+      const wellKnownUrls = this.buildWellKnownUrls(serverUrl, false);
+
+      // Try to get the protected resource metadata at root
+      let resourceMetadata = await this.fetchProtectedResourceMetadata(
+        wellKnownUrls.protectedResource,
+      );
+
+      // If root discovery fails and we have a path, try path-based discovery
+      if (!resourceMetadata) {
+        const url = new URL(serverUrl);
+        if (url.pathname && url.pathname !== '/') {
+          const pathBasedUrls = this.buildWellKnownUrls(serverUrl, true);
+          resourceMetadata = await this.fetchProtectedResourceMetadata(
+            pathBasedUrls.protectedResource,
+          );
+        }
+      }
+
+      if (resourceMetadata?.authorization_servers?.length) {
+        // Use the first authorization server
+        const authServerUrl = resourceMetadata.authorization_servers[0];
+
+        // The authorization server URL may include a path (e.g., https://github.com/login/oauth)
+        // We need to preserve this path when constructing the metadata URL
+        const authServerUrlObj = new URL(authServerUrl);
+        const authServerPath =
+          authServerUrlObj.pathname === '/' ? '' : authServerUrlObj.pathname;
+
+        // Try with the authorization server's path first
+        let authServerMetadataUrl = new URL(
+          `/.well-known/oauth-authorization-server${authServerPath}`,
+          `${authServerUrlObj.protocol}//${authServerUrlObj.host}`,
+        ).toString();
+
+        let authServerMetadata = await this.fetchAuthorizationServerMetadata(
+          authServerMetadataUrl,
+        );
+
+        // If that fails, try root as fallback
+        if (!authServerMetadata && authServerPath) {
+          authServerMetadataUrl = new URL(
+            '/.well-known/oauth-authorization-server',
+            `${authServerUrlObj.protocol}//${authServerUrlObj.host}`,
+          ).toString();
+          authServerMetadata = await this.fetchAuthorizationServerMetadata(
+            authServerMetadataUrl,
+          );
+        }
+
+        if (authServerMetadata) {
+          const config = this.metadataToOAuthConfig(authServerMetadata);
+          if (authServerMetadata.registration_endpoint) {
+            console.log(
+              'Dynamic client registration is supported at:',
+              authServerMetadata.registration_endpoint,
+            );
+          }
+          return config;
+        }
+      }
+
+      // Fallback: try /.well-known/oauth-authorization-server at the base URL
+      console.debug(
+        `Trying OAuth discovery fallback at ${wellKnownUrls.authorizationServer}`,
+      );
+      const authServerMetadata = await this.fetchAuthorizationServerMetadata(
+        wellKnownUrls.authorizationServer,
+      );
+
+      if (authServerMetadata) {
+        const config = this.metadataToOAuthConfig(authServerMetadata);
+        if (authServerMetadata.registration_endpoint) {
+          console.log(
+            'Dynamic client registration is supported at:',
+            authServerMetadata.registration_endpoint,
+          );
+        }
+        return config;
+      }
+
+      return null;
+    } catch (error) {
+      console.debug(
+        `Failed to discover OAuth configuration: ${getErrorMessage(error)}`,
+      );
+      return null;
+    }
+  }
+
+  /**
+   * Parse WWW-Authenticate header to extract OAuth information.
+   *
+   * @param header The WWW-Authenticate header value
+   * @returns The resource metadata URI if found
+   */
+  static parseWWWAuthenticateHeader(header: string): string | null {
+    // Parse Bearer realm and resource_metadata
+    const match = header.match(/resource_metadata="([^"]+)"/);
+    if (match) {
+      return match[1];
+    }
+    return null;
+  }
+
+  /**
+   * Discover OAuth configuration from WWW-Authenticate header.
+   *
+   * @param wwwAuthenticate The WWW-Authenticate header value
+   * @returns The discovered OAuth configuration or null if not available
+   */
+  static async discoverOAuthFromWWWAuthenticate(
+    wwwAuthenticate: string,
+  ): Promise<MCPOAuthConfig | null> {
+    const resourceMetadataUri =
+      this.parseWWWAuthenticateHeader(wwwAuthenticate);
+    if (!resourceMetadataUri) {
+      return null;
+    }
+
+    const resourceMetadata =
+      await this.fetchProtectedResourceMetadata(resourceMetadataUri);
+    if (!resourceMetadata?.authorization_servers?.length) {
+      return null;
+    }
+
+    const authServerUrl = resourceMetadata.authorization_servers[0];
+
+    // The authorization server URL may include a path (e.g., https://github.com/login/oauth)
+    // We need to preserve this path when constructing the metadata URL
+    const authServerUrlObj = new URL(authServerUrl);
+    const authServerPath =
+      authServerUrlObj.pathname === '/' ? '' : authServerUrlObj.pathname;
+
+    // Build auth server metadata URL with the authorization server's path
+    const authServerMetadataUrl = new URL(
+      `/.well-known/oauth-authorization-server${authServerPath}`,
+      `${authServerUrlObj.protocol}//${authServerUrlObj.host}`,
+    ).toString();
+
+    let authServerMetadata = await this.fetchAuthorizationServerMetadata(
+      authServerMetadataUrl,
+    );
+
+    // If that fails and we have a path, also try the root path as a fallback
+    if (!authServerMetadata && authServerPath) {
+      const rootAuthServerMetadataUrl = new URL(
+        '/.well-known/oauth-authorization-server',
+        `${authServerUrlObj.protocol}//${authServerUrlObj.host}`,
+      ).toString();
+
+      authServerMetadata = await this.fetchAuthorizationServerMetadata(
+        rootAuthServerMetadataUrl,
+      );
+    }
+
+    if (authServerMetadata) {
+      return this.metadataToOAuthConfig(authServerMetadata);
+    }
+
+    return null;
+  }
+
+  /**
+   * Extract base URL from an MCP server URL.
+   *
+   * @param mcpServerUrl The MCP server URL
+   * @returns The base URL
+   */
+  static extractBaseUrl(mcpServerUrl: string): string {
+    const serverUrl = new URL(mcpServerUrl);
+    return `${serverUrl.protocol}//${serverUrl.host}`;
+  }
+
+  /**
+   * Check if a URL is an SSE endpoint.
+   *
+   * @param url The URL to check
+   * @returns True if the URL appears to be an SSE endpoint
+   */
+  static isSSEEndpoint(url: string): boolean {
+    return url.includes('/sse') || !url.includes('/mcp');
+  }
+
+  /**
+   * Build a resource parameter for OAuth requests.
+   *
+   * @param endpointUrl The endpoint URL
+   * @returns The resource parameter value
+   */
+  static buildResourceParameter(endpointUrl: string): string {
+    const url = new URL(endpointUrl);
+    return `${url.protocol}//${url.host}`;
+  }
+}

projects/ui/qwen-code/packages/core/src/mocks/msw.ts

@@ -0,0 +1,9 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { setupServer } from 'msw/node';
+
+export const server = setupServer();

projects/ui/qwen-code/packages/core/src/prompts/mcp-prompts.ts

@@ -0,0 +1,19 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { Config } from '../config/config.js';
+import { DiscoveredMCPPrompt } from '../tools/mcp-client.js';
+
+export function getMCPServerPrompts(
+  config: Config,
+  serverName: string,
+): DiscoveredMCPPrompt[] {
+  const promptRegistry = config.getPromptRegistry();
+  if (!promptRegistry) {
+    return [];
+  }
+  return promptRegistry.getPromptsByServer(serverName);
+}

projects/ui/qwen-code/packages/core/src/prompts/prompt-registry.ts

@@ -0,0 +1,74 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { DiscoveredMCPPrompt } from '../tools/mcp-client.js';
+
+export class PromptRegistry {
+  private prompts: Map<string, DiscoveredMCPPrompt> = new Map();
+
+  /**
+   * Registers a prompt definition.
+   * @param prompt - The prompt object containing schema and execution logic.
+   */
+  registerPrompt(prompt: DiscoveredMCPPrompt): void {
+    if (this.prompts.has(prompt.name)) {
+      const newName = `${prompt.serverName}_${prompt.name}`;
+      console.warn(
+        `Prompt with name "${prompt.name}" is already registered. Renaming to "${newName}".`,
+      );
+      this.prompts.set(newName, { ...prompt, name: newName });
+    } else {
+      this.prompts.set(prompt.name, prompt);
+    }
+  }
+
+  /**
+   * Returns an array of all registered and discovered prompt instances.
+   */
+  getAllPrompts(): DiscoveredMCPPrompt[] {
+    return Array.from(this.prompts.values()).sort((a, b) =>
+      a.name.localeCompare(b.name),
+    );
+  }
+
+  /**
+   * Get the definition of a specific prompt.
+   */
+  getPrompt(name: string): DiscoveredMCPPrompt | undefined {
+    return this.prompts.get(name);
+  }
+
+  /**
+   * Returns an array of prompts registered from a specific MCP server.
+   */
+  getPromptsByServer(serverName: string): DiscoveredMCPPrompt[] {
+    const serverPrompts: DiscoveredMCPPrompt[] = [];
+    for (const prompt of this.prompts.values()) {
+      if (prompt.serverName === serverName) {
+        serverPrompts.push(prompt);
+      }
+    }
+    return serverPrompts.sort((a, b) => a.name.localeCompare(b.name));
+  }
+
+  /**
+   * Clears all the prompts from the registry.
+   */
+  clear(): void {
+    this.prompts.clear();
+  }
+
+  /**
+   * Removes all prompts from a specific server.
+   */
+  removePromptsByServer(serverName: string): void {
+    for (const [name, prompt] of this.prompts.entries()) {
+      if (prompt.serverName === serverName) {
+        this.prompts.delete(name);
+      }
+    }
+  }
+}

projects/ui/qwen-code/packages/core/src/qwen/qwenContentGenerator.test.ts

@@ -0,0 +1,1601 @@
+/**
+ * @license
+ * Copyright 2025 Qwen
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import {
+  IQwenOAuth2Client,
+  type QwenCredentials,
+  type ErrorData,
+} from './qwenOAuth2.js';
+import {
+  GenerateContentParameters,
+  GenerateContentResponse,
+  CountTokensParameters,
+  CountTokensResponse,
+  EmbedContentParameters,
+  EmbedContentResponse,
+  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 {
+    client: {
+      apiKey: string;
+      baseURL: string;
+    };
+
+    constructor(
+      contentGeneratorConfig: ContentGeneratorConfig,
+      _config: Config,
+    ) {
+      this.client = {
+        apiKey: contentGeneratorConfig.apiKey || 'test-key',
+        baseURL: contentGeneratorConfig.baseUrl || 'https://api.openai.com/v1',
+      };
+    }
+
+    async generateContent(
+      _request: GenerateContentParameters,
+    ): Promise<GenerateContentResponse> {
+      return createMockResponse('Generated content');
+    }
+
+    async generateContentStream(
+      _request: GenerateContentParameters,
+    ): Promise<AsyncGenerator<GenerateContentResponse>> {
+      return (async function* () {
+        yield createMockResponse('Stream chunk 1');
+        yield createMockResponse('Stream chunk 2');
+      })();
+    }
+
+    async countTokens(
+      _request: CountTokensParameters,
+    ): Promise<CountTokensResponse> {
+      return { totalTokens: 10 };
+    }
+
+    async embedContent(
+      _request: EmbedContentParameters,
+    ): Promise<EmbedContentResponse> {
+      return { embeddings: [{ values: [0.1, 0.2, 0.3] }] };
+    }
+
+    protected shouldSuppressErrorLogging(
+      _error: unknown,
+      _request: GenerateContentParameters,
+    ): boolean {
+      return false;
+    }
+  },
+}));
+
+const createMockResponse = (text: string): GenerateContentResponse =>
+  ({
+    candidates: [
+      {
+        content: { role: 'model', parts: [{ text }] },
+        finishReason: FinishReason.STOP,
+        index: 0,
+        safetyRatings: [],
+      },
+    ],
+    promptFeedback: { safetyRatings: [] },
+    text,
+    data: undefined,
+    functionCalls: [],
+    executableCode: '',
+    codeExecutionResult: '',
+  }) as GenerateContentResponse;
+
+describe('QwenContentGenerator', () => {
+  let mockQwenClient: IQwenOAuth2Client;
+  let qwenContentGenerator: QwenContentGenerator;
+  let mockConfig: Config;
+
+  const mockCredentials: QwenCredentials = {
+    access_token: 'test-access-token',
+    refresh_token: 'test-refresh-token',
+    resource_url: 'https://test-endpoint.com/v1',
+  };
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+
+    // Mock Config
+    mockConfig = {
+      getContentGeneratorConfig: vi.fn().mockReturnValue({
+        authType: 'qwen',
+        enableOpenAILogging: false,
+        timeout: 120000,
+        maxRetries: 3,
+        samplingParams: {
+          temperature: 0.7,
+          max_tokens: 1000,
+          top_p: 0.9,
+        },
+      }),
+    } as unknown as Config;
+
+    // Mock QwenOAuth2Client
+    mockQwenClient = {
+      getAccessToken: vi.fn(),
+      getCredentials: vi.fn(),
+      setCredentials: vi.fn(),
+      refreshAccessToken: vi.fn(),
+      requestDeviceAuthorization: vi.fn(),
+      pollDeviceToken: vi.fn(),
+    };
+
+    // Create QwenContentGenerator instance
+    const contentGeneratorConfig = {
+      model: 'qwen-turbo',
+      authType: AuthType.QWEN_OAUTH,
+    };
+    qwenContentGenerator = new QwenContentGenerator(
+      mockQwenClient,
+      contentGeneratorConfig,
+      mockConfig,
+    );
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  describe('Core Content Generation Methods', () => {
+    it('should generate content with valid token', async () => {
+      vi.mocked(mockQwenClient.getAccessToken).mockResolvedValue({
+        token: 'valid-token',
+      });
+      vi.mocked(mockQwenClient.getCredentials).mockReturnValue(mockCredentials);
+
+      const request: GenerateContentParameters = {
+        model: 'qwen-turbo',
+        contents: [{ role: 'user', parts: [{ text: 'Hello' }] }],
+      };
+
+      const result = await qwenContentGenerator.generateContent(
+        request,
+        'test-prompt-id',
+      );
+
+      expect(result.text).toBe('Generated content');
+      expect(mockQwenClient.getAccessToken).toHaveBeenCalled();
+    });
+
+    it('should generate content stream with valid token', async () => {
+      vi.mocked(mockQwenClient.getAccessToken).mockResolvedValue({
+        token: 'valid-token',
+      });
+      vi.mocked(mockQwenClient.getCredentials).mockReturnValue(mockCredentials);
+
+      const request: GenerateContentParameters = {
+        model: 'qwen-turbo',
+        contents: [{ role: 'user', parts: [{ text: 'Hello stream' }] }],
+      };
+
+      const stream = await qwenContentGenerator.generateContentStream(
+        request,
+        'test-prompt-id',
+      );
+      const chunks: string[] = [];
+
+      for await (const chunk of stream) {
+        chunks.push(chunk.text || '');
+      }
+
+      expect(chunks).toEqual(['Stream chunk 1', 'Stream chunk 2']);
+      expect(mockQwenClient.getAccessToken).toHaveBeenCalled();
+    });
+
+    it('should count tokens with valid token', async () => {
+      vi.mocked(mockQwenClient.getAccessToken).mockResolvedValue({
+        token: 'valid-token',
+      });
+      vi.mocked(mockQwenClient.getCredentials).mockReturnValue(mockCredentials);
+
+      const request: CountTokensParameters = {
+        model: 'qwen-turbo',
+        contents: [{ role: 'user', parts: [{ text: 'Count me' }] }],
+      };
+
+      const result = await qwenContentGenerator.countTokens(request);
+
+      expect(result.totalTokens).toBe(10);
+      expect(mockQwenClient.getAccessToken).toHaveBeenCalled();
+    });
+
+    it('should embed content with valid token', async () => {
+      vi.mocked(mockQwenClient.getAccessToken).mockResolvedValue({
+        token: 'valid-token',
+      });
+      vi.mocked(mockQwenClient.getCredentials).mockReturnValue(mockCredentials);
+
+      const request: EmbedContentParameters = {
+        model: 'qwen-turbo',
+        contents: [{ parts: [{ text: 'Embed me' }] }],
+      };
+
+      const result = await qwenContentGenerator.embedContent(request);
+
+      expect(result.embeddings).toHaveLength(1);
+      expect(result.embeddings?.[0]?.values).toEqual([0.1, 0.2, 0.3]);
+      expect(mockQwenClient.getAccessToken).toHaveBeenCalled();
+    });
+  });
+
+  describe('Token Management and Refresh Logic', () => {
+    it('should refresh token on auth error and retry', async () => {
+      const authError = { status: 401, message: 'Unauthorized' };
+
+      // 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({
+        access_token: 'refreshed-token',
+        token_type: 'Bearer',
+        expires_in: 3600,
+        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' }] }],
+      };
+
+      const result = await qwenContentGenerator.generateContent(
+        request,
+        'test-prompt-id',
+      );
+
+      expect(result.text).toBe('Generated content');
+      expect(mockQwenClient.refreshAccessToken).toHaveBeenCalled();
+    });
+
+    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',
+      );
+      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 = {
+        model: 'qwen-turbo',
+        contents: [{ role: 'user', parts: [{ text: 'Hello' }] }],
+      };
+
+      await expect(
+        qwenContentGenerator.generateContent(request, 'test-prompt-id'),
+      ).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 () => {
+      vi.mocked(mockQwenClient.getAccessToken).mockResolvedValue({
+        token: 'valid-token',
+      });
+      vi.mocked(mockQwenClient.getCredentials).mockReturnValue({
+        ...mockCredentials,
+        resource_url: 'https://new-endpoint.com',
+      });
+
+      const request: GenerateContentParameters = {
+        model: 'qwen-turbo',
+        contents: [{ role: 'user', parts: [{ text: 'Hello' }] }],
+      };
+
+      await qwenContentGenerator.generateContent(request, 'test-prompt-id');
+
+      expect(mockQwenClient.getCredentials).toHaveBeenCalled();
+    });
+  });
+
+  describe('Endpoint URL Normalization', () => {
+    it('should use default endpoint when no custom endpoint provided', async () => {
+      let capturedBaseURL = '';
+
+      vi.mocked(mockQwenClient.getAccessToken).mockResolvedValue({
+        token: 'valid-token',
+      });
+      vi.mocked(mockQwenClient.getCredentials).mockReturnValue({
+        access_token: 'test-token',
+        refresh_token: 'test-refresh',
+        // No resource_url provided
+      });
+
+      // Mock the parent's generateContent to capture the baseURL during the call
+      const parentPrototype = Object.getPrototypeOf(
+        Object.getPrototypeOf(qwenContentGenerator),
+      );
+      const originalGenerateContent = parentPrototype.generateContent;
+      parentPrototype.generateContent = vi.fn().mockImplementation(function (
+        this: QwenContentGenerator,
+      ) {
+        capturedBaseURL = (this as unknown as { client: { baseURL: string } })
+          .client.baseURL;
+        return createMockResponse('Generated content');
+      });
+
+      const request: GenerateContentParameters = {
+        model: 'qwen-turbo',
+        contents: [{ role: 'user', parts: [{ text: 'Hello' }] }],
+      };
+
+      await qwenContentGenerator.generateContent(request, 'test-prompt-id');
+
+      // Should use default endpoint with /v1 suffix
+      expect(capturedBaseURL).toBe(
+        'https://dashscope.aliyuncs.com/compatible-mode/v1',
+      );
+
+      // Restore original method
+      parentPrototype.generateContent = originalGenerateContent;
+    });
+
+    it('should normalize hostname-only endpoints by adding https protocol', async () => {
+      let capturedBaseURL = '';
+
+      vi.mocked(mockQwenClient.getAccessToken).mockResolvedValue({
+        token: 'valid-token',
+      });
+      vi.mocked(mockQwenClient.getCredentials).mockReturnValue({
+        ...mockCredentials,
+        resource_url: 'custom-endpoint.com',
+      });
+
+      // Mock the parent's generateContent to capture the baseURL during the call
+      const parentPrototype = Object.getPrototypeOf(
+        Object.getPrototypeOf(qwenContentGenerator),
+      );
+      const originalGenerateContent = parentPrototype.generateContent;
+      parentPrototype.generateContent = vi.fn().mockImplementation(function (
+        this: QwenContentGenerator,
+      ) {
+        capturedBaseURL = (this as unknown as { client: { baseURL: string } })
+          .client.baseURL;
+        return createMockResponse('Generated content');
+      });
+
+      const request: GenerateContentParameters = {
+        model: 'qwen-turbo',
+        contents: [{ role: 'user', parts: [{ text: 'Hello' }] }],
+      };
+
+      await qwenContentGenerator.generateContent(request, 'test-prompt-id');
+
+      // Should add https:// and /v1
+      expect(capturedBaseURL).toBe('https://custom-endpoint.com/v1');
+
+      // Restore original method
+      parentPrototype.generateContent = originalGenerateContent;
+    });
+
+    it('should preserve existing protocol in endpoint URLs', async () => {
+      let capturedBaseURL = '';
+
+      vi.mocked(mockQwenClient.getAccessToken).mockResolvedValue({
+        token: 'valid-token',
+      });
+      vi.mocked(mockQwenClient.getCredentials).mockReturnValue({
+        ...mockCredentials,
+        resource_url: 'https://custom-endpoint.com',
+      });
+
+      // Mock the parent's generateContent to capture the baseURL during the call
+      const parentPrototype = Object.getPrototypeOf(
+        Object.getPrototypeOf(qwenContentGenerator),
+      );
+      const originalGenerateContent = parentPrototype.generateContent;
+      parentPrototype.generateContent = vi.fn().mockImplementation(function (
+        this: QwenContentGenerator,
+      ) {
+        capturedBaseURL = (this as unknown as { client: { baseURL: string } })
+          .client.baseURL;
+        return createMockResponse('Generated content');
+      });
+
+      const request: GenerateContentParameters = {
+        model: 'qwen-turbo',
+        contents: [{ role: 'user', parts: [{ text: 'Hello' }] }],
+      };
+
+      await qwenContentGenerator.generateContent(request, 'test-prompt-id');
+
+      // Should preserve https:// and add /v1
+      expect(capturedBaseURL).toBe('https://custom-endpoint.com/v1');
+
+      // Restore original method
+      parentPrototype.generateContent = originalGenerateContent;
+    });
+
+    it('should not duplicate /v1 suffix if already present', async () => {
+      let capturedBaseURL = '';
+
+      vi.mocked(mockQwenClient.getAccessToken).mockResolvedValue({
+        token: 'valid-token',
+      });
+      vi.mocked(mockQwenClient.getCredentials).mockReturnValue({
+        ...mockCredentials,
+        resource_url: 'https://custom-endpoint.com/v1',
+      });
+
+      // Mock the parent's generateContent to capture the baseURL during the call
+      const parentPrototype = Object.getPrototypeOf(
+        Object.getPrototypeOf(qwenContentGenerator),
+      );
+      const originalGenerateContent = parentPrototype.generateContent;
+      parentPrototype.generateContent = vi.fn().mockImplementation(function (
+        this: QwenContentGenerator,
+      ) {
+        capturedBaseURL = (this as unknown as { client: { baseURL: string } })
+          .client.baseURL;
+        return createMockResponse('Generated content');
+      });
+
+      const request: GenerateContentParameters = {
+        model: 'qwen-turbo',
+        contents: [{ role: 'user', parts: [{ text: 'Hello' }] }],
+      };
+
+      await qwenContentGenerator.generateContent(request, 'test-prompt-id');
+
+      // Should not duplicate /v1
+      expect(capturedBaseURL).toBe('https://custom-endpoint.com/v1');
+
+      // Restore original method
+      parentPrototype.generateContent = originalGenerateContent;
+    });
+  });
+
+  describe('Client State Management', () => {
+    it('should restore original client credentials after operations', 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: 'temp-token',
+      });
+      vi.mocked(mockQwenClient.getCredentials).mockReturnValue({
+        ...mockCredentials,
+        resource_url: 'https://temp-endpoint.com',
+      });
+
+      const request: GenerateContentParameters = {
+        model: 'qwen-turbo',
+        contents: [{ role: 'user', parts: [{ text: 'Hello' }] }],
+      };
+
+      await qwenContentGenerator.generateContent(request, 'test-prompt-id');
+
+      // Should restore original values after operation
+      expect(client.apiKey).toBe(originalApiKey);
+      expect(client.baseURL).toBe(originalBaseURL);
+    });
+
+    it('should restore credentials even when operation throws', 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: 'temp-token',
+      });
+      vi.mocked(mockQwenClient.getCredentials).mockReturnValue(mockCredentials);
+
+      // Mock the parent method to throw an error
+      const mockError = new Error('Network error');
+      const parentPrototype = Object.getPrototypeOf(
+        Object.getPrototypeOf(qwenContentGenerator),
+      );
+      const originalGenerateContent = parentPrototype.generateContent;
+      parentPrototype.generateContent = vi.fn().mockRejectedValue(mockError);
+
+      const request: GenerateContentParameters = {
+        model: 'qwen-turbo',
+        contents: [{ role: 'user', parts: [{ text: 'Hello' }] }],
+      };
+
+      try {
+        await qwenContentGenerator.generateContent(request, 'test-prompt-id');
+      } catch (error) {
+        expect(error).toBe(mockError);
+      }
+
+      // Credentials should still be restored
+      expect(client.apiKey).toBe(originalApiKey);
+      expect(client.baseURL).toBe(originalBaseURL);
+
+      // Restore original method
+      parentPrototype.generateContent = originalGenerateContent;
+    });
+  });
+
+  describe('Error Handling and Retry Logic', () => {
+    it('should retry once on authentication errors', async () => {
+      const authError = { status: 401, message: 'Unauthorized' };
+
+      // Mock first call to fail with auth error
+      const mockGenerateContent = vi
+        .fn()
+        .mockRejectedValueOnce(authError)
+        .mockResolvedValueOnce(createMockResponse('Success after retry'));
+
+      // Replace the parent method
+      const parentPrototype = Object.getPrototypeOf(
+        Object.getPrototypeOf(qwenContentGenerator),
+      );
+      const originalGenerateContent = parentPrototype.generateContent;
+      parentPrototype.generateContent = mockGenerateContent;
+
+      // 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({
+        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',
+        expires_in: 3600,
+      });
+
+      const request: GenerateContentParameters = {
+        model: 'qwen-turbo',
+        contents: [{ role: 'user', parts: [{ text: 'Hello' }] }],
+      };
+
+      const result = await qwenContentGenerator.generateContent(
+        request,
+        'test-prompt-id',
+      );
+
+      expect(result.text).toBe('Success after retry');
+      expect(mockGenerateContent).toHaveBeenCalledTimes(2);
+      expect(mockQwenClient.refreshAccessToken).toHaveBeenCalled();
+
+      // Restore original method
+      parentPrototype.generateContent = originalGenerateContent;
+    });
+
+    it('should not retry non-authentication errors', async () => {
+      const networkError = new Error('Network timeout');
+
+      const mockGenerateContent = vi.fn().mockRejectedValue(networkError);
+      const parentPrototype = Object.getPrototypeOf(
+        Object.getPrototypeOf(qwenContentGenerator),
+      );
+      const originalGenerateContent = parentPrototype.generateContent;
+      parentPrototype.generateContent = mockGenerateContent;
+
+      vi.mocked(mockQwenClient.getAccessToken).mockResolvedValue({
+        token: 'valid-token',
+      });
+      vi.mocked(mockQwenClient.getCredentials).mockReturnValue(mockCredentials);
+
+      const request: GenerateContentParameters = {
+        model: 'qwen-turbo',
+        contents: [{ role: 'user', parts: [{ text: 'Hello' }] }],
+      };
+
+      await expect(
+        qwenContentGenerator.generateContent(request, 'test-prompt-id'),
+      ).rejects.toThrow('Network timeout');
+      expect(mockGenerateContent).toHaveBeenCalledTimes(1);
+      expect(mockQwenClient.refreshAccessToken).not.toHaveBeenCalled();
+
+      // Restore original method
+      parentPrototype.generateContent = originalGenerateContent;
+    });
+
+    it('should handle error response from token refresh', async () => {
+      vi.mocked(mockQwenClient.getAccessToken).mockRejectedValue(
+        new Error('Token expired'),
+      );
+      vi.mocked(mockQwenClient.refreshAccessToken).mockResolvedValue({
+        error: 'invalid_grant',
+        error_description: 'Refresh token expired',
+      } as ErrorData);
+
+      const request: GenerateContentParameters = {
+        model: 'qwen-turbo',
+        contents: [{ role: 'user', parts: [{ text: 'Hello' }] }],
+      };
+
+      await expect(
+        qwenContentGenerator.generateContent(request, 'test-prompt-id'),
+      ).rejects.toThrow('Failed to obtain valid Qwen access token');
+    });
+  });
+
+  describe('Token State Management', () => {
+    it('should cache and return current token', () => {
+      expect(qwenContentGenerator.getCurrentToken()).toBeNull();
+
+      // Simulate setting a token internally
+      (
+        qwenContentGenerator as unknown as { currentToken: string }
+      ).currentToken = 'cached-token';
+
+      expect(qwenContentGenerator.getCurrentToken()).toBe('cached-token');
+    });
+
+    it('should clear token on clearToken()', () => {
+      // Simulate having cached token value
+      const qwenInstance = qwenContentGenerator as unknown as {
+        currentToken: string;
+      };
+      qwenInstance.currentToken = 'cached-token';
+
+      qwenContentGenerator.clearToken();
+
+      expect(qwenContentGenerator.getCurrentToken()).toBeNull();
+    });
+
+    it('should handle concurrent token refresh requests', async () => {
+      let refreshCallCount = 0;
+
+      // Clear any existing cached token first
+      qwenContentGenerator.clearToken();
+
+      // Mock to simulate auth error on first parent call, which should trigger refresh
+      const authError = { status: 401, message: 'Unauthorized' };
+      let parentCallCount = 0;
+
+      vi.mocked(mockQwenClient.getAccessToken).mockRejectedValue(authError);
+      vi.mocked(mockQwenClient.getCredentials).mockReturnValue(mockCredentials);
+
+      vi.mocked(mockQwenClient.refreshAccessToken).mockImplementation(
+        async () => {
+          refreshCallCount++;
+          await new Promise((resolve) => setTimeout(resolve, 50)); // Longer delay to ensure concurrency
+          return {
+            access_token: 'refreshed-token',
+            token_type: 'Bearer',
+            expires_in: 3600,
+          };
+        },
+      );
+
+      // Mock the parent method to fail first then succeed
+      const parentPrototype = Object.getPrototypeOf(
+        Object.getPrototypeOf(qwenContentGenerator),
+      );
+      const originalGenerateContent = parentPrototype.generateContent;
+      parentPrototype.generateContent = vi.fn().mockImplementation(async () => {
+        parentCallCount++;
+        if (parentCallCount === 1) {
+          throw authError; // First call triggers auth error
+        }
+        return createMockResponse('Generated content');
+      });
+
+      const request: GenerateContentParameters = {
+        model: 'qwen-turbo',
+        contents: [{ role: 'user', parts: [{ text: 'Hello' }] }],
+      };
+
+      // Make multiple concurrent requests - should all use the same refresh promise
+      const promises = [
+        qwenContentGenerator.generateContent(request, 'test-prompt-id'),
+        qwenContentGenerator.generateContent(request, 'test-prompt-id'),
+        qwenContentGenerator.generateContent(request, 'test-prompt-id'),
+      ];
+
+      const results = await Promise.all(promises);
+
+      // All should succeed
+      results.forEach((result) => {
+        expect(result.text).toBe('Generated content');
+      });
+
+      // 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
+      parentPrototype.generateContent = originalGenerateContent;
+    });
+  });
+
+  describe('Error Logging Suppression', () => {
+    it('should suppress logging for authentication errors', () => {
+      const authErrors = [
+        { status: 401 },
+        { code: 403 },
+        new Error('Unauthorized access'),
+        new Error('Token expired'),
+        new Error('Invalid API key'),
+      ];
+
+      authErrors.forEach((error) => {
+        const shouldSuppress = (
+          qwenContentGenerator as unknown as {
+            shouldSuppressErrorLogging: (
+              error: unknown,
+              request: GenerateContentParameters,
+            ) => boolean;
+          }
+        ).shouldSuppressErrorLogging(error, {} as GenerateContentParameters);
+        expect(shouldSuppress).toBe(true);
+      });
+    });
+
+    it('should not suppress logging for non-auth errors', () => {
+      const nonAuthErrors = [
+        new Error('Network timeout'),
+        new Error('Rate limit exceeded'),
+        { status: 500 },
+        new Error('Internal server error'),
+      ];
+
+      nonAuthErrors.forEach((error) => {
+        const shouldSuppress = (
+          qwenContentGenerator as unknown as {
+            shouldSuppressErrorLogging: (
+              error: unknown,
+              request: GenerateContentParameters,
+            ) => boolean;
+          }
+        ).shouldSuppressErrorLogging(error, {} as GenerateContentParameters);
+        expect(shouldSuppress).toBe(false);
+      });
+    });
+  });
+
+  describe('Integration Tests', () => {
+    it('should handle complete workflow: get token, use it, refresh on auth error, retry', async () => {
+      const authError = { status: 401, message: 'Token expired' };
+
+      // Setup complex scenario
+      let callCount = 0;
+      const mockGenerateContent = vi.fn().mockImplementation(async () => {
+        callCount++;
+        if (callCount === 1) {
+          throw authError; // First call fails
+        }
+        return createMockResponse('Success after refresh'); // Second call succeeds
+      });
+
+      const parentPrototype = Object.getPrototypeOf(
+        Object.getPrototypeOf(qwenContentGenerator),
+      );
+      parentPrototype.generateContent = mockGenerateContent;
+
+      // 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({
+        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',
+        expires_in: 7200,
+        resource_url: 'https://new-endpoint.com',
+      });
+
+      const request: GenerateContentParameters = {
+        model: 'qwen-turbo',
+        contents: [{ role: 'user', parts: [{ text: 'Test message' }] }],
+      };
+
+      const result = await qwenContentGenerator.generateContent(
+        request,
+        'test-prompt-id',
+      );
+
+      expect(result.text).toBe('Success after refresh');
+      expect(mockQwenClient.getAccessToken).toHaveBeenCalled();
+      expect(mockQwenClient.refreshAccessToken).toHaveBeenCalled();
+      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;
+    });
+  });
+});

projects/ui/qwen-code/packages/core/src/qwen/qwenContentGenerator.ts

@@ -0,0 +1,277 @@
+/**
+ * @license
+ * Copyright 2025 Qwen
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { OpenAIContentGenerator } from '../core/openaiContentGenerator.js';
+import { IQwenOAuth2Client } from './qwenOAuth2.js';
+import { SharedTokenManager } from './sharedTokenManager.js';
+import { Config } from '../config/config.js';
+import {
+  GenerateContentParameters,
+  GenerateContentResponse,
+  CountTokensParameters,
+  CountTokensResponse,
+  EmbedContentParameters,
+  EmbedContentResponse,
+} from '@google/genai';
+import { ContentGeneratorConfig } from '../core/contentGenerator.js';
+
+// Default fallback base URL if no endpoint is provided
+const DEFAULT_QWEN_BASE_URL =
+  'https://dashscope.aliyuncs.com/compatible-mode/v1';
+
+/**
+ * Qwen Content Generator that uses Qwen OAuth tokens with automatic refresh
+ */
+export class QwenContentGenerator extends OpenAIContentGenerator {
+  private qwenClient: IQwenOAuth2Client;
+  private sharedManager: SharedTokenManager;
+  private currentToken?: string;
+
+  constructor(
+    qwenClient: IQwenOAuth2Client,
+    contentGeneratorConfig: ContentGeneratorConfig,
+    config: Config,
+  ) {
+    // Initialize with empty API key, we'll override it dynamically
+    super(contentGeneratorConfig, config);
+    this.qwenClient = qwenClient;
+    this.sharedManager = SharedTokenManager.getInstance();
+
+    // Set default base URL, will be updated dynamically
+    this.client.baseURL = DEFAULT_QWEN_BASE_URL;
+  }
+
+  /**
+   * Get the current endpoint URL with proper protocol and /v1 suffix
+   */
+  private getCurrentEndpoint(resourceUrl?: string): string {
+    const baseEndpoint = resourceUrl || DEFAULT_QWEN_BASE_URL;
+    const suffix = '/v1';
+
+    // Normalize the URL: add protocol if missing, ensure /v1 suffix
+    const normalizedUrl = baseEndpoint.startsWith('http')
+      ? baseEndpoint
+      : `https://${baseEndpoint}`;
+
+    return normalizedUrl.endsWith(suffix)
+      ? normalizedUrl
+      : `${normalizedUrl}${suffix}`;
+  }
+
+  /**
+   * Override error logging behavior to suppress auth errors during token refresh
+   */
+  protected override shouldSuppressErrorLogging(
+    error: unknown,
+    _request: GenerateContentParameters,
+  ): boolean {
+    // Suppress logging for authentication errors that we handle with token refresh
+    return this.isAuthError(error);
+  }
+
+  /**
+   * Get valid token and endpoint using the shared token manager
+   */
+  private async getValidToken(): Promise<{ token: string; endpoint: string }> {
+    try {
+      // Use SharedTokenManager for consistent token/endpoint pairing and automatic refresh
+      const credentials = await this.sharedManager.getValidCredentials(
+        this.qwenClient,
+      );
+
+      if (!credentials.access_token) {
+        throw new Error('No access token available');
+      }
+
+      return {
+        token: credentials.access_token,
+        endpoint: this.getCurrentEndpoint(credentials.resource_url),
+      };
+    } catch (error) {
+      // Propagate auth errors as-is for retry logic
+      if (this.isAuthError(error)) {
+        throw error;
+      }
+      console.warn('Failed to get token from shared manager:', error);
+      throw new Error(
+        'Failed to obtain valid Qwen access token. Please re-authenticate.',
+      );
+    }
+  }
+
+  /**
+   * Execute an operation with automatic credential management and retry logic.
+   * This method handles:
+   * - Dynamic token and endpoint retrieval
+   * - Temporary client configuration updates
+   * - Automatic restoration of original configuration
+   * - Retry logic on authentication errors with token refresh
+   *
+   * @param operation - The operation to execute with updated client configuration
+   * @param restoreOnCompletion - Whether to restore original config after operation completes
+   * @returns The result of the operation
+   */
+  private async executeWithCredentialManagement<T>(
+    operation: () => Promise<T>,
+    restoreOnCompletion: boolean = true,
+  ): Promise<T> {
+    // Attempt the operation with credential management and retry logic
+    const attemptOperation = async (): Promise<T> => {
+      const { token, endpoint } = await this.getValidToken();
+
+      // Store original configuration
+      const originalApiKey = this.client.apiKey;
+      const originalBaseURL = this.client.baseURL;
+
+      // Apply dynamic configuration
+      this.client.apiKey = token;
+      this.client.baseURL = endpoint;
+
+      try {
+        const result = await operation();
+
+        // For streaming operations, we may need to keep the configuration active
+        if (restoreOnCompletion) {
+          this.client.apiKey = originalApiKey;
+          this.client.baseURL = originalBaseURL;
+        }
+
+        return result;
+      } catch (error) {
+        // Always restore on error
+        this.client.apiKey = originalApiKey;
+        this.client.baseURL = originalBaseURL;
+        throw error;
+      }
+    };
+
+    // Execute with retry logic for auth errors
+    try {
+      return await attemptOperation();
+    } catch (error) {
+      if (this.isAuthError(error)) {
+        try {
+          // Use SharedTokenManager to properly refresh and persist the token
+          // This ensures the refreshed token is saved to oauth_creds.json
+          await this.sharedManager.getValidCredentials(this.qwenClient, true);
+          // Retry the operation once with fresh credentials
+          return await attemptOperation();
+        } catch (_refreshError) {
+          throw new Error(
+            'Failed to obtain valid Qwen access token. Please re-authenticate.',
+          );
+        }
+      }
+      throw error;
+    }
+  }
+
+  /**
+   * Override to use dynamic token and endpoint with automatic retry
+   */
+  override async generateContent(
+    request: GenerateContentParameters,
+    userPromptId: string,
+  ): Promise<GenerateContentResponse> {
+    return this.executeWithCredentialManagement(() =>
+      super.generateContent(request, userPromptId),
+    );
+  }
+
+  /**
+   * Override to use dynamic token and endpoint with automatic retry.
+   * Note: For streaming, the client configuration is not restored immediately
+   * since the generator may continue to be used after this method returns.
+   */
+  override async generateContentStream(
+    request: GenerateContentParameters,
+    userPromptId: string,
+  ): Promise<AsyncGenerator<GenerateContentResponse>> {
+    return this.executeWithCredentialManagement(
+      () => super.generateContentStream(request, userPromptId),
+      false, // Don't restore immediately for streaming
+    );
+  }
+
+  /**
+   * Override to use dynamic token and endpoint with automatic retry
+   */
+  override async countTokens(
+    request: CountTokensParameters,
+  ): Promise<CountTokensResponse> {
+    return this.executeWithCredentialManagement(() =>
+      super.countTokens(request),
+    );
+  }
+
+  /**
+   * Override to use dynamic token and endpoint with automatic retry
+   */
+  override async embedContent(
+    request: EmbedContentParameters,
+  ): Promise<EmbedContentResponse> {
+    return this.executeWithCredentialManagement(() =>
+      super.embedContent(request),
+    );
+  }
+
+  /**
+   * Check if an error is related to authentication/authorization
+   */
+  private isAuthError(error: unknown): boolean {
+    if (!error) return false;
+
+    const errorMessage =
+      error instanceof Error
+        ? error.message.toLowerCase()
+        : String(error).toLowerCase();
+
+    // Define a type for errors that might have status or code properties
+    const errorWithCode = error as {
+      status?: number | string;
+      code?: number | string;
+    };
+    const errorCode = errorWithCode?.status || errorWithCode?.code;
+
+    return (
+      errorCode === 401 ||
+      errorCode === 403 ||
+      errorCode === '401' ||
+      errorCode === '403' ||
+      errorMessage.includes('unauthorized') ||
+      errorMessage.includes('forbidden') ||
+      errorMessage.includes('invalid api key') ||
+      errorMessage.includes('invalid access token') ||
+      errorMessage.includes('token expired') ||
+      errorMessage.includes('authentication') ||
+      errorMessage.includes('access denied') ||
+      (errorMessage.includes('token') && errorMessage.includes('expired'))
+    );
+  }
+
+  /**
+   * Get the current cached token (may be expired)
+   */
+  getCurrentToken(): string | null {
+    // First check internal state for backwards compatibility with tests
+    if (this.currentToken) {
+      return this.currentToken;
+    }
+    // Fall back to SharedTokenManager
+    const credentials = this.sharedManager.getCurrentCredentials();
+    return credentials?.access_token || null;
+  }
+
+  /**
+   * Clear the cached token
+   */
+  clearToken(): void {
+    // Clear internal state for backwards compatibility with tests
+    this.currentToken = undefined;
+    // Also clear SharedTokenManager
+    this.sharedManager.clearCache();
+  }
+}