Add files using upload-large-folder tool

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

@@ -0,0 +1,353 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { describe, it, expect } from 'vitest';
+import {
+  toGenerateContentRequest,
+  fromGenerateContentResponse,
+  CaGenerateContentResponse,
+  toContents,
+} from './converter.js';
+import {
+  ContentListUnion,
+  GenerateContentParameters,
+  GenerateContentResponse,
+  FinishReason,
+  BlockedReason,
+} from '@google/genai';
+
+describe('converter', () => {
+  describe('toCodeAssistRequest', () => {
+    it('should convert a simple request with project', () => {
+      const genaiReq: GenerateContentParameters = {
+        model: 'gemini-pro',
+        contents: [{ role: 'user', parts: [{ text: 'Hello' }] }],
+      };
+      const codeAssistReq = toGenerateContentRequest(
+        genaiReq,
+        'my-prompt',
+        'my-project',
+        'my-session',
+      );
+      expect(codeAssistReq).toEqual({
+        model: 'gemini-pro',
+        project: 'my-project',
+        request: {
+          contents: [{ role: 'user', parts: [{ text: 'Hello' }] }],
+          systemInstruction: undefined,
+          cachedContent: undefined,
+          tools: undefined,
+          toolConfig: undefined,
+          labels: undefined,
+          safetySettings: undefined,
+          generationConfig: undefined,
+          session_id: 'my-session',
+        },
+        user_prompt_id: 'my-prompt',
+      });
+    });
+
+    it('should convert a request without a project', () => {
+      const genaiReq: GenerateContentParameters = {
+        model: 'gemini-pro',
+        contents: [{ role: 'user', parts: [{ text: 'Hello' }] }],
+      };
+      const codeAssistReq = toGenerateContentRequest(
+        genaiReq,
+        'my-prompt',
+        undefined,
+        'my-session',
+      );
+      expect(codeAssistReq).toEqual({
+        model: 'gemini-pro',
+        project: undefined,
+        request: {
+          contents: [{ role: 'user', parts: [{ text: 'Hello' }] }],
+          systemInstruction: undefined,
+          cachedContent: undefined,
+          tools: undefined,
+          toolConfig: undefined,
+          labels: undefined,
+          safetySettings: undefined,
+          generationConfig: undefined,
+          session_id: 'my-session',
+        },
+        user_prompt_id: 'my-prompt',
+      });
+    });
+
+    it('should convert a request with sessionId', () => {
+      const genaiReq: GenerateContentParameters = {
+        model: 'gemini-pro',
+        contents: [{ role: 'user', parts: [{ text: 'Hello' }] }],
+      };
+      const codeAssistReq = toGenerateContentRequest(
+        genaiReq,
+        'my-prompt',
+        'my-project',
+        'session-123',
+      );
+      expect(codeAssistReq).toEqual({
+        model: 'gemini-pro',
+        project: 'my-project',
+        request: {
+          contents: [{ role: 'user', parts: [{ text: 'Hello' }] }],
+          systemInstruction: undefined,
+          cachedContent: undefined,
+          tools: undefined,
+          toolConfig: undefined,
+          labels: undefined,
+          safetySettings: undefined,
+          generationConfig: undefined,
+          session_id: 'session-123',
+        },
+        user_prompt_id: 'my-prompt',
+      });
+    });
+
+    it('should handle string content', () => {
+      const genaiReq: GenerateContentParameters = {
+        model: 'gemini-pro',
+        contents: 'Hello',
+      };
+      const codeAssistReq = toGenerateContentRequest(
+        genaiReq,
+        'my-prompt',
+        'my-project',
+        'my-session',
+      );
+      expect(codeAssistReq.request.contents).toEqual([
+        { role: 'user', parts: [{ text: 'Hello' }] },
+      ]);
+    });
+
+    it('should handle Part[] content', () => {
+      const genaiReq: GenerateContentParameters = {
+        model: 'gemini-pro',
+        contents: [{ text: 'Hello' }, { text: 'World' }],
+      };
+      const codeAssistReq = toGenerateContentRequest(
+        genaiReq,
+        'my-prompt',
+        'my-project',
+        'my-session',
+      );
+      expect(codeAssistReq.request.contents).toEqual([
+        { role: 'user', parts: [{ text: 'Hello' }] },
+        { role: 'user', parts: [{ text: 'World' }] },
+      ]);
+    });
+
+    it('should handle system instructions', () => {
+      const genaiReq: GenerateContentParameters = {
+        model: 'gemini-pro',
+        contents: 'Hello',
+        config: {
+          systemInstruction: 'You are a helpful assistant.',
+        },
+      };
+      const codeAssistReq = toGenerateContentRequest(
+        genaiReq,
+        'my-prompt',
+        'my-project',
+        'my-session',
+      );
+      expect(codeAssistReq.request.systemInstruction).toEqual({
+        role: 'user',
+        parts: [{ text: 'You are a helpful assistant.' }],
+      });
+    });
+
+    it('should handle generation config', () => {
+      const genaiReq: GenerateContentParameters = {
+        model: 'gemini-pro',
+        contents: 'Hello',
+        config: {
+          temperature: 0.8,
+          topK: 40,
+        },
+      };
+      const codeAssistReq = toGenerateContentRequest(
+        genaiReq,
+        'my-prompt',
+        'my-project',
+        'my-session',
+      );
+      expect(codeAssistReq.request.generationConfig).toEqual({
+        temperature: 0.8,
+        topK: 40,
+      });
+    });
+
+    it('should handle all generation config fields', () => {
+      const genaiReq: GenerateContentParameters = {
+        model: 'gemini-pro',
+        contents: 'Hello',
+        config: {
+          temperature: 0.1,
+          topP: 0.2,
+          topK: 3,
+          candidateCount: 4,
+          maxOutputTokens: 5,
+          stopSequences: ['a'],
+          responseLogprobs: true,
+          logprobs: 6,
+          presencePenalty: 0.7,
+          frequencyPenalty: 0.8,
+          seed: 9,
+          responseMimeType: 'application/json',
+        },
+      };
+      const codeAssistReq = toGenerateContentRequest(
+        genaiReq,
+        'my-prompt',
+        'my-project',
+        'my-session',
+      );
+      expect(codeAssistReq.request.generationConfig).toEqual({
+        temperature: 0.1,
+        topP: 0.2,
+        topK: 3,
+        candidateCount: 4,
+        maxOutputTokens: 5,
+        stopSequences: ['a'],
+        responseLogprobs: true,
+        logprobs: 6,
+        presencePenalty: 0.7,
+        frequencyPenalty: 0.8,
+        seed: 9,
+        responseMimeType: 'application/json',
+      });
+    });
+  });
+
+  describe('fromCodeAssistResponse', () => {
+    it('should convert a simple response', () => {
+      const codeAssistRes: CaGenerateContentResponse = {
+        response: {
+          candidates: [
+            {
+              index: 0,
+              content: {
+                role: 'model',
+                parts: [{ text: 'Hi there!' }],
+              },
+              finishReason: FinishReason.STOP,
+              safetyRatings: [],
+            },
+          ],
+        },
+      };
+      const genaiRes = fromGenerateContentResponse(codeAssistRes);
+      expect(genaiRes).toBeInstanceOf(GenerateContentResponse);
+      expect(genaiRes.candidates).toEqual(codeAssistRes.response.candidates);
+    });
+
+    it('should handle prompt feedback and usage metadata', () => {
+      const codeAssistRes: CaGenerateContentResponse = {
+        response: {
+          candidates: [],
+          promptFeedback: {
+            blockReason: BlockedReason.SAFETY,
+            safetyRatings: [],
+          },
+          usageMetadata: {
+            promptTokenCount: 10,
+            candidatesTokenCount: 20,
+            totalTokenCount: 30,
+          },
+        },
+      };
+      const genaiRes = fromGenerateContentResponse(codeAssistRes);
+      expect(genaiRes.promptFeedback).toEqual(
+        codeAssistRes.response.promptFeedback,
+      );
+      expect(genaiRes.usageMetadata).toEqual(
+        codeAssistRes.response.usageMetadata,
+      );
+    });
+
+    it('should handle automatic function calling history', () => {
+      const codeAssistRes: CaGenerateContentResponse = {
+        response: {
+          candidates: [],
+          automaticFunctionCallingHistory: [
+            {
+              role: 'model',
+              parts: [
+                {
+                  functionCall: {
+                    name: 'test_function',
+                    args: {
+                      foo: 'bar',
+                    },
+                  },
+                },
+              ],
+            },
+          ],
+        },
+      };
+      const genaiRes = fromGenerateContentResponse(codeAssistRes);
+      expect(genaiRes.automaticFunctionCallingHistory).toEqual(
+        codeAssistRes.response.automaticFunctionCallingHistory,
+      );
+    });
+  });
+
+  describe('toContents', () => {
+    it('should handle Content', () => {
+      const content: ContentListUnion = {
+        role: 'user',
+        parts: [{ text: 'hello' }],
+      };
+      expect(toContents(content)).toEqual([
+        { role: 'user', parts: [{ text: 'hello' }] },
+      ]);
+    });
+
+    it('should handle array of Contents', () => {
+      const contents: ContentListUnion = [
+        { role: 'user', parts: [{ text: 'hello' }] },
+        { role: 'model', parts: [{ text: 'hi' }] },
+      ];
+      expect(toContents(contents)).toEqual([
+        { role: 'user', parts: [{ text: 'hello' }] },
+        { role: 'model', parts: [{ text: 'hi' }] },
+      ]);
+    });
+
+    it('should handle Part', () => {
+      const part: ContentListUnion = { text: 'a part' };
+      expect(toContents(part)).toEqual([
+        { role: 'user', parts: [{ text: 'a part' }] },
+      ]);
+    });
+
+    it('should handle array of Parts', () => {
+      const parts = [{ text: 'part 1' }, 'part 2'];
+      expect(toContents(parts)).toEqual([
+        { role: 'user', parts: [{ text: 'part 1' }] },
+        { role: 'user', parts: [{ text: 'part 2' }] },
+      ]);
+    });
+
+    it('should handle string', () => {
+      const str: ContentListUnion = 'a string';
+      expect(toContents(str)).toEqual([
+        { role: 'user', parts: [{ text: 'a string' }] },
+      ]);
+    });
+
+    it('should handle array of strings', () => {
+      const strings: ContentListUnion = ['string 1', 'string 2'];
+      expect(toContents(strings)).toEqual([
+        { role: 'user', parts: [{ text: 'string 1' }] },
+        { role: 'user', parts: [{ text: 'string 2' }] },
+      ]);
+    });
+  });
+});

projects/ui/qwen-code/packages/core/src/code_assist/converter.ts

@@ -0,0 +1,243 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import {
+  Content,
+  ContentListUnion,
+  ContentUnion,
+  GenerateContentConfig,
+  GenerateContentParameters,
+  CountTokensParameters,
+  CountTokensResponse,
+  GenerateContentResponse,
+  GenerationConfigRoutingConfig,
+  MediaResolution,
+  Candidate,
+  ModelSelectionConfig,
+  GenerateContentResponsePromptFeedback,
+  GenerateContentResponseUsageMetadata,
+  Part,
+  SafetySetting,
+  PartUnion,
+  SpeechConfigUnion,
+  ThinkingConfig,
+  ToolListUnion,
+  ToolConfig,
+} from '@google/genai';
+
+export interface CAGenerateContentRequest {
+  model: string;
+  project?: string;
+  user_prompt_id?: string;
+  request: VertexGenerateContentRequest;
+}
+
+interface VertexGenerateContentRequest {
+  contents: Content[];
+  systemInstruction?: Content;
+  cachedContent?: string;
+  tools?: ToolListUnion;
+  toolConfig?: ToolConfig;
+  labels?: Record<string, string>;
+  safetySettings?: SafetySetting[];
+  generationConfig?: VertexGenerationConfig;
+  session_id?: string;
+}
+
+interface VertexGenerationConfig {
+  temperature?: number;
+  topP?: number;
+  topK?: number;
+  candidateCount?: number;
+  maxOutputTokens?: number;
+  stopSequences?: string[];
+  responseLogprobs?: boolean;
+  logprobs?: number;
+  presencePenalty?: number;
+  frequencyPenalty?: number;
+  seed?: number;
+  responseMimeType?: string;
+  responseJsonSchema?: unknown;
+  responseSchema?: unknown;
+  routingConfig?: GenerationConfigRoutingConfig;
+  modelSelectionConfig?: ModelSelectionConfig;
+  responseModalities?: string[];
+  mediaResolution?: MediaResolution;
+  speechConfig?: SpeechConfigUnion;
+  audioTimestamp?: boolean;
+  thinkingConfig?: ThinkingConfig;
+}
+
+export interface CaGenerateContentResponse {
+  response: VertexGenerateContentResponse;
+}
+
+interface VertexGenerateContentResponse {
+  candidates: Candidate[];
+  automaticFunctionCallingHistory?: Content[];
+  promptFeedback?: GenerateContentResponsePromptFeedback;
+  usageMetadata?: GenerateContentResponseUsageMetadata;
+}
+
+export interface CaCountTokenRequest {
+  request: VertexCountTokenRequest;
+}
+
+interface VertexCountTokenRequest {
+  model: string;
+  contents: Content[];
+}
+
+export interface CaCountTokenResponse {
+  totalTokens: number;
+}
+
+export function toCountTokenRequest(
+  req: CountTokensParameters,
+): CaCountTokenRequest {
+  return {
+    request: {
+      model: 'models/' + req.model,
+      contents: toContents(req.contents),
+    },
+  };
+}
+
+export function fromCountTokenResponse(
+  res: CaCountTokenResponse,
+): CountTokensResponse {
+  return {
+    totalTokens: res.totalTokens,
+  };
+}
+
+export function toGenerateContentRequest(
+  req: GenerateContentParameters,
+  userPromptId: string,
+  project?: string,
+  sessionId?: string,
+): CAGenerateContentRequest {
+  return {
+    model: req.model,
+    project,
+    user_prompt_id: userPromptId,
+    request: toVertexGenerateContentRequest(req, sessionId),
+  };
+}
+
+export function fromGenerateContentResponse(
+  res: CaGenerateContentResponse,
+): GenerateContentResponse {
+  const inres = res.response;
+  const out = new GenerateContentResponse();
+  out.candidates = inres.candidates;
+  out.automaticFunctionCallingHistory = inres.automaticFunctionCallingHistory;
+  out.promptFeedback = inres.promptFeedback;
+  out.usageMetadata = inres.usageMetadata;
+  return out;
+}
+
+function toVertexGenerateContentRequest(
+  req: GenerateContentParameters,
+  sessionId?: string,
+): VertexGenerateContentRequest {
+  return {
+    contents: toContents(req.contents),
+    systemInstruction: maybeToContent(req.config?.systemInstruction),
+    cachedContent: req.config?.cachedContent,
+    tools: req.config?.tools,
+    toolConfig: req.config?.toolConfig,
+    labels: req.config?.labels,
+    safetySettings: req.config?.safetySettings,
+    generationConfig: toVertexGenerationConfig(req.config),
+    session_id: sessionId,
+  };
+}
+
+export function toContents(contents: ContentListUnion): Content[] {
+  if (Array.isArray(contents)) {
+    // it's a Content[] or a PartsUnion[]
+    return contents.map(toContent);
+  }
+  // it's a Content or a PartsUnion
+  return [toContent(contents)];
+}
+
+function maybeToContent(content?: ContentUnion): Content | undefined {
+  if (!content) {
+    return undefined;
+  }
+  return toContent(content);
+}
+
+function toContent(content: ContentUnion): Content {
+  if (Array.isArray(content)) {
+    // it's a PartsUnion[]
+    return {
+      role: 'user',
+      parts: toParts(content),
+    };
+  }
+  if (typeof content === 'string') {
+    // it's a string
+    return {
+      role: 'user',
+      parts: [{ text: content }],
+    };
+  }
+  if ('parts' in content) {
+    // it's a Content
+    return content;
+  }
+  // it's a Part
+  return {
+    role: 'user',
+    parts: [content as Part],
+  };
+}
+
+function toParts(parts: PartUnion[]): Part[] {
+  return parts.map(toPart);
+}
+
+function toPart(part: PartUnion): Part {
+  if (typeof part === 'string') {
+    // it's a string
+    return { text: part };
+  }
+  return part;
+}
+
+function toVertexGenerationConfig(
+  config?: GenerateContentConfig,
+): VertexGenerationConfig | undefined {
+  if (!config) {
+    return undefined;
+  }
+  return {
+    temperature: config.temperature,
+    topP: config.topP,
+    topK: config.topK,
+    candidateCount: config.candidateCount,
+    maxOutputTokens: config.maxOutputTokens,
+    stopSequences: config.stopSequences,
+    responseLogprobs: config.responseLogprobs,
+    logprobs: config.logprobs,
+    presencePenalty: config.presencePenalty,
+    frequencyPenalty: config.frequencyPenalty,
+    seed: config.seed,
+    responseMimeType: config.responseMimeType,
+    responseSchema: config.responseSchema,
+    responseJsonSchema: config.responseJsonSchema,
+    routingConfig: config.routingConfig,
+    modelSelectionConfig: config.modelSelectionConfig,
+    responseModalities: config.responseModalities,
+    mediaResolution: config.mediaResolution,
+    speechConfig: config.speechConfig,
+    audioTimestamp: config.audioTimestamp,
+    thinkingConfig: config.thinkingConfig,
+  };
+}

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

@@ -0,0 +1,590 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { describe, it, expect, vi, beforeEach, afterEach, Mock } from 'vitest';
+import {
+  getOauthClient,
+  resetOauthClientForTesting,
+  clearCachedCredentialFile,
+  clearOauthClientCache,
+} from './oauth2.js';
+import { getCachedGoogleAccount } from '../utils/user_account.js';
+import { OAuth2Client, Compute } from 'google-auth-library';
+import * as fs from 'fs';
+import * as path from 'path';
+import http from 'http';
+import open from 'open';
+import crypto from 'crypto';
+import * as os from 'os';
+import { AuthType } from '../core/contentGenerator.js';
+import { Config } from '../config/config.js';
+import readline from 'node:readline';
+import { QWEN_DIR } from '../utils/paths.js';
+
+vi.mock('os', async (importOriginal) => {
+  const os = await importOriginal<typeof import('os')>();
+  return {
+    ...os,
+    homedir: vi.fn(),
+  };
+});
+
+vi.mock('google-auth-library');
+vi.mock('http');
+vi.mock('open');
+vi.mock('crypto');
+vi.mock('node:readline');
+vi.mock('../utils/browser.js', () => ({
+  shouldAttemptBrowserLaunch: () => true,
+}));
+
+const mockConfig = {
+  getNoBrowser: () => false,
+  getProxy: () => 'http://test.proxy.com:8080',
+  isBrowserLaunchSuppressed: () => false,
+} as unknown as Config;
+
+// Mock fetch globally
+global.fetch = vi.fn();
+
+describe('oauth2', () => {
+  let tempHomeDir: string;
+
+  beforeEach(() => {
+    tempHomeDir = fs.mkdtempSync(
+      path.join(os.tmpdir(), 'qwen-code-test-home-'),
+    );
+    (os.homedir as Mock).mockReturnValue(tempHomeDir);
+  });
+  afterEach(() => {
+    fs.rmSync(tempHomeDir, { recursive: true, force: true });
+    vi.clearAllMocks();
+    resetOauthClientForTesting();
+    vi.unstubAllEnvs();
+  });
+
+  it('should perform a web login', async () => {
+    const mockAuthUrl = 'https://example.com/auth';
+    const mockCode = 'test-code';
+    const mockState = 'test-state';
+    const mockTokens = {
+      access_token: 'test-access-token',
+      refresh_token: 'test-refresh-token',
+    };
+
+    const mockGenerateAuthUrl = vi.fn().mockReturnValue(mockAuthUrl);
+    const mockGetToken = vi.fn().mockResolvedValue({ tokens: mockTokens });
+    const mockSetCredentials = vi.fn();
+    const mockGetAccessToken = vi
+      .fn()
+      .mockResolvedValue({ token: 'mock-access-token' });
+    const mockOAuth2Client = {
+      generateAuthUrl: mockGenerateAuthUrl,
+      getToken: mockGetToken,
+      setCredentials: mockSetCredentials,
+      getAccessToken: mockGetAccessToken,
+      credentials: mockTokens,
+      on: vi.fn(),
+    } as unknown as OAuth2Client;
+    (OAuth2Client as unknown as Mock).mockImplementation(
+      () => mockOAuth2Client,
+    );
+
+    vi.spyOn(crypto, 'randomBytes').mockReturnValue(mockState as never);
+    (open as Mock).mockImplementation(async () => ({ on: vi.fn() }) as never);
+
+    // Mock the UserInfo API response
+    (global.fetch as Mock).mockResolvedValue({
+      ok: true,
+      json: vi
+        .fn()
+        .mockResolvedValue({ email: 'test-google-account@gmail.com' }),
+    } as unknown as Response);
+
+    let requestCallback!: http.RequestListener<
+      typeof http.IncomingMessage,
+      typeof http.ServerResponse
+    >;
+
+    let serverListeningCallback: (value: unknown) => void;
+    const serverListeningPromise = new Promise(
+      (resolve) => (serverListeningCallback = resolve),
+    );
+
+    let capturedPort = 0;
+    const mockHttpServer = {
+      listen: vi.fn((port: number, _host: string, callback?: () => void) => {
+        capturedPort = port;
+        if (callback) {
+          callback();
+        }
+        serverListeningCallback(undefined);
+      }),
+      close: vi.fn((callback?: () => void) => {
+        if (callback) {
+          callback();
+        }
+      }),
+      on: vi.fn(),
+      address: () => ({ port: capturedPort }),
+    };
+    (http.createServer as Mock).mockImplementation((cb) => {
+      requestCallback = cb as http.RequestListener<
+        typeof http.IncomingMessage,
+        typeof http.ServerResponse
+      >;
+      return mockHttpServer as unknown as http.Server;
+    });
+
+    const clientPromise = getOauthClient(
+      AuthType.LOGIN_WITH_GOOGLE,
+      mockConfig,
+    );
+
+    // wait for server to start listening.
+    await serverListeningPromise;
+
+    const mockReq = {
+      url: `/oauth2callback?code=${mockCode}&state=${mockState}`,
+    } as http.IncomingMessage;
+    const mockRes = {
+      writeHead: vi.fn(),
+      end: vi.fn(),
+    } as unknown as http.ServerResponse;
+
+    await requestCallback(mockReq, mockRes);
+
+    const client = await clientPromise;
+    expect(client).toBe(mockOAuth2Client);
+
+    expect(open).toHaveBeenCalledWith(mockAuthUrl);
+    expect(mockGetToken).toHaveBeenCalledWith({
+      code: mockCode,
+      redirect_uri: `http://localhost:${capturedPort}/oauth2callback`,
+    });
+    expect(mockSetCredentials).toHaveBeenCalledWith(mockTokens);
+
+    // Verify Google Account was cached
+    const googleAccountPath = path.join(
+      tempHomeDir,
+      QWEN_DIR,
+      'google_accounts.json',
+    );
+    expect(fs.existsSync(googleAccountPath)).toBe(true);
+    const cachedGoogleAccount = fs.readFileSync(googleAccountPath, 'utf-8');
+    expect(JSON.parse(cachedGoogleAccount)).toEqual({
+      active: 'test-google-account@gmail.com',
+      old: [],
+    });
+
+    // Verify the getCachedGoogleAccount function works
+    expect(getCachedGoogleAccount()).toBe('test-google-account@gmail.com');
+  });
+
+  it('should perform login with user code', async () => {
+    const mockConfigWithNoBrowser = {
+      getNoBrowser: () => true,
+      getProxy: () => 'http://test.proxy.com:8080',
+      isBrowserLaunchSuppressed: () => true,
+    } as unknown as Config;
+
+    const mockCodeVerifier = {
+      codeChallenge: 'test-challenge',
+      codeVerifier: 'test-verifier',
+    };
+    const mockAuthUrl = 'https://example.com/auth-user-code';
+    const mockCode = 'test-user-code';
+    const mockTokens = {
+      access_token: 'test-access-token-user-code',
+      refresh_token: 'test-refresh-token-user-code',
+    };
+
+    const mockGenerateAuthUrl = vi.fn().mockReturnValue(mockAuthUrl);
+    const mockGetToken = vi.fn().mockResolvedValue({ tokens: mockTokens });
+    const mockSetCredentials = vi.fn();
+    const mockGenerateCodeVerifierAsync = vi
+      .fn()
+      .mockResolvedValue(mockCodeVerifier);
+
+    const mockOAuth2Client = {
+      generateAuthUrl: mockGenerateAuthUrl,
+      getToken: mockGetToken,
+      setCredentials: mockSetCredentials,
+      generateCodeVerifierAsync: mockGenerateCodeVerifierAsync,
+      on: vi.fn(),
+    } as unknown as OAuth2Client;
+    (OAuth2Client as unknown as Mock).mockImplementation(
+      () => mockOAuth2Client,
+    );
+
+    const mockReadline = {
+      question: vi.fn((_query, callback) => callback(mockCode)),
+      close: vi.fn(),
+    };
+    (readline.createInterface as Mock).mockReturnValue(mockReadline);
+
+    const consoleLogSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+
+    const client = await getOauthClient(
+      AuthType.LOGIN_WITH_GOOGLE,
+      mockConfigWithNoBrowser,
+    );
+
+    expect(client).toBe(mockOAuth2Client);
+
+    // Verify the auth flow
+    expect(mockGenerateCodeVerifierAsync).toHaveBeenCalled();
+    expect(mockGenerateAuthUrl).toHaveBeenCalled();
+    expect(consoleLogSpy).toHaveBeenCalledWith(
+      expect.stringContaining(mockAuthUrl),
+    );
+    expect(mockReadline.question).toHaveBeenCalledWith(
+      'Enter the authorization code: ',
+      expect.any(Function),
+    );
+    expect(mockGetToken).toHaveBeenCalledWith({
+      code: mockCode,
+      codeVerifier: mockCodeVerifier.codeVerifier,
+      redirect_uri: 'https://codeassist.google.com/authcode',
+    });
+    expect(mockSetCredentials).toHaveBeenCalledWith(mockTokens);
+
+    consoleLogSpy.mockRestore();
+  });
+
+  describe('in Cloud Shell', () => {
+    const mockGetAccessToken = vi.fn();
+    let mockComputeClient: Compute;
+
+    beforeEach(() => {
+      mockGetAccessToken.mockResolvedValue({ token: 'test-access-token' });
+      mockComputeClient = {
+        credentials: { refresh_token: 'test-refresh-token' },
+        getAccessToken: mockGetAccessToken,
+      } as unknown as Compute;
+
+      (Compute as unknown as Mock).mockImplementation(() => mockComputeClient);
+    });
+
+    it('should attempt to load cached credentials first', async () => {
+      const cachedCreds = { refresh_token: 'cached-token' };
+      const credsPath = path.join(tempHomeDir, QWEN_DIR, 'oauth_creds.json');
+      await fs.promises.mkdir(path.dirname(credsPath), { recursive: true });
+      await fs.promises.writeFile(credsPath, JSON.stringify(cachedCreds));
+
+      const mockClient = {
+        setCredentials: vi.fn(),
+        getAccessToken: vi.fn().mockResolvedValue({ token: 'test-token' }),
+        getTokenInfo: vi.fn().mockResolvedValue({}),
+        on: vi.fn(),
+      };
+
+      // To mock the new OAuth2Client() inside the function
+      (OAuth2Client as unknown as Mock).mockImplementation(
+        () => mockClient as unknown as OAuth2Client,
+      );
+
+      await getOauthClient(AuthType.LOGIN_WITH_GOOGLE, mockConfig);
+
+      expect(mockClient.setCredentials).toHaveBeenCalledWith(cachedCreds);
+      expect(mockClient.getAccessToken).toHaveBeenCalled();
+      expect(mockClient.getTokenInfo).toHaveBeenCalled();
+      expect(Compute).not.toHaveBeenCalled(); // Should not fetch new client if cache is valid
+    });
+
+    it('should use Compute to get a client if no cached credentials exist', async () => {
+      await getOauthClient(AuthType.CLOUD_SHELL, mockConfig);
+
+      expect(Compute).toHaveBeenCalledWith({});
+      expect(mockGetAccessToken).toHaveBeenCalled();
+    });
+
+    it('should not cache the credentials after fetching them via ADC', async () => {
+      const newCredentials = { refresh_token: 'new-adc-token' };
+      mockComputeClient.credentials = newCredentials;
+      mockGetAccessToken.mockResolvedValue({ token: 'new-adc-token' });
+
+      await getOauthClient(AuthType.CLOUD_SHELL, mockConfig);
+
+      const credsPath = path.join(tempHomeDir, QWEN_DIR, 'oauth_creds.json');
+      expect(fs.existsSync(credsPath)).toBe(false);
+    });
+
+    it('should return the Compute client on successful ADC authentication', async () => {
+      const client = await getOauthClient(AuthType.CLOUD_SHELL, mockConfig);
+      expect(client).toBe(mockComputeClient);
+    });
+
+    it('should throw an error if ADC fails', async () => {
+      const testError = new Error('ADC Failed');
+      mockGetAccessToken.mockRejectedValue(testError);
+
+      await expect(
+        getOauthClient(AuthType.CLOUD_SHELL, mockConfig),
+      ).rejects.toThrow(
+        'Could not authenticate using Cloud Shell credentials. Please select a different authentication method or ensure you are in a properly configured environment. Error: ADC Failed',
+      );
+    });
+  });
+
+  describe('credential loading order', () => {
+    it('should prioritize default cached credentials over GOOGLE_APPLICATION_CREDENTIALS', async () => {
+      // Setup default cached credentials
+      const defaultCreds = { refresh_token: 'default-cached-token' };
+      const defaultCredsPath = path.join(
+        tempHomeDir,
+        QWEN_DIR,
+        'oauth_creds.json',
+      );
+      await fs.promises.mkdir(path.dirname(defaultCredsPath), {
+        recursive: true,
+      });
+      await fs.promises.writeFile(
+        defaultCredsPath,
+        JSON.stringify(defaultCreds),
+      );
+
+      // Setup credentials via environment variable
+      const envCreds = { refresh_token: 'env-var-token' };
+      const envCredsPath = path.join(tempHomeDir, 'env_creds.json');
+      await fs.promises.writeFile(envCredsPath, JSON.stringify(envCreds));
+      vi.stubEnv('GOOGLE_APPLICATION_CREDENTIALS', envCredsPath);
+
+      const mockClient = {
+        setCredentials: vi.fn(),
+        getAccessToken: vi.fn().mockResolvedValue({ token: 'test-token' }),
+        getTokenInfo: vi.fn().mockResolvedValue({}),
+        on: vi.fn(),
+      };
+      (OAuth2Client as unknown as Mock).mockImplementation(
+        () => mockClient as unknown as OAuth2Client,
+      );
+
+      await getOauthClient(AuthType.LOGIN_WITH_GOOGLE, mockConfig);
+
+      // Assert the correct credentials were used
+      expect(mockClient.setCredentials).toHaveBeenCalledWith(defaultCreds);
+      expect(mockClient.setCredentials).not.toHaveBeenCalledWith(envCreds);
+    });
+
+    it('should fall back to GOOGLE_APPLICATION_CREDENTIALS if default cache is missing', async () => {
+      // Setup credentials via environment variable
+      const envCreds = { refresh_token: 'env-var-token' };
+      const envCredsPath = path.join(tempHomeDir, 'env_creds.json');
+      await fs.promises.writeFile(envCredsPath, JSON.stringify(envCreds));
+      vi.stubEnv('GOOGLE_APPLICATION_CREDENTIALS', envCredsPath);
+
+      const mockClient = {
+        setCredentials: vi.fn(),
+        getAccessToken: vi.fn().mockResolvedValue({ token: 'test-token' }),
+        getTokenInfo: vi.fn().mockResolvedValue({}),
+        on: vi.fn(),
+      };
+      (OAuth2Client as unknown as Mock).mockImplementation(
+        () => mockClient as unknown as OAuth2Client,
+      );
+
+      await getOauthClient(AuthType.LOGIN_WITH_GOOGLE, mockConfig);
+
+      // Assert the correct credentials were used
+      expect(mockClient.setCredentials).toHaveBeenCalledWith(envCreds);
+    });
+  });
+
+  describe('with GCP environment variables', () => {
+    it('should use GOOGLE_CLOUD_ACCESS_TOKEN when GOOGLE_GENAI_USE_GCA is true', async () => {
+      vi.stubEnv('GOOGLE_GENAI_USE_GCA', 'true');
+      vi.stubEnv('GOOGLE_CLOUD_ACCESS_TOKEN', 'gcp-access-token');
+
+      const mockSetCredentials = vi.fn();
+      const mockGetAccessToken = vi
+        .fn()
+        .mockResolvedValue({ token: 'gcp-access-token' });
+      const mockOAuth2Client = {
+        setCredentials: mockSetCredentials,
+        getAccessToken: mockGetAccessToken,
+        on: vi.fn(),
+      } as unknown as OAuth2Client;
+      (OAuth2Client as unknown as Mock).mockImplementation(
+        () => mockOAuth2Client,
+      );
+
+      // Mock the UserInfo API response for fetchAndCacheUserInfo
+      (global.fetch as Mock).mockResolvedValue({
+        ok: true,
+        json: vi
+          .fn()
+          .mockResolvedValue({ email: 'test-gcp-account@gmail.com' }),
+      } as unknown as Response);
+
+      const client = await getOauthClient(
+        AuthType.LOGIN_WITH_GOOGLE,
+        mockConfig,
+      );
+
+      expect(client).toBe(mockOAuth2Client);
+      expect(mockSetCredentials).toHaveBeenCalledWith({
+        access_token: 'gcp-access-token',
+      });
+
+      // Verify fetchAndCacheUserInfo was effectively called
+      expect(mockGetAccessToken).toHaveBeenCalled();
+      expect(global.fetch).toHaveBeenCalledWith(
+        'https://www.googleapis.com/oauth2/v2/userinfo',
+        {
+          headers: {
+            Authorization: 'Bearer gcp-access-token',
+          },
+        },
+      );
+
+      // Verify Google Account was cached
+      const googleAccountPath = path.join(
+        tempHomeDir,
+        QWEN_DIR,
+        'google_accounts.json',
+      );
+      const cachedContent = fs.readFileSync(googleAccountPath, 'utf-8');
+      expect(JSON.parse(cachedContent)).toEqual({
+        active: 'test-gcp-account@gmail.com',
+        old: [],
+      });
+    });
+
+    it('should not use GCP token if GOOGLE_CLOUD_ACCESS_TOKEN is not set', async () => {
+      vi.stubEnv('GOOGLE_GENAI_USE_GCA', 'true');
+
+      const mockSetCredentials = vi.fn();
+      const mockGetAccessToken = vi
+        .fn()
+        .mockResolvedValue({ token: 'cached-access-token' });
+      const mockGetTokenInfo = vi.fn().mockResolvedValue({});
+      const mockOAuth2Client = {
+        setCredentials: mockSetCredentials,
+        getAccessToken: mockGetAccessToken,
+        getTokenInfo: mockGetTokenInfo,
+        on: vi.fn(),
+      } as unknown as OAuth2Client;
+      (OAuth2Client as unknown as Mock).mockImplementation(
+        () => mockOAuth2Client,
+      );
+
+      // Make it fall through to cached credentials path
+      const cachedCreds = { refresh_token: 'cached-token' };
+      const credsPath = path.join(tempHomeDir, QWEN_DIR, 'oauth_creds.json');
+      await fs.promises.mkdir(path.dirname(credsPath), { recursive: true });
+      await fs.promises.writeFile(credsPath, JSON.stringify(cachedCreds));
+
+      await getOauthClient(AuthType.LOGIN_WITH_GOOGLE, mockConfig);
+
+      // It should be called with the cached credentials, not the GCP access token.
+      expect(mockSetCredentials).toHaveBeenCalledTimes(1);
+      expect(mockSetCredentials).toHaveBeenCalledWith(cachedCreds);
+    });
+
+    it('should not use GCP token if GOOGLE_GENAI_USE_GCA is not set', async () => {
+      vi.stubEnv('GOOGLE_CLOUD_ACCESS_TOKEN', 'gcp-access-token');
+
+      const mockSetCredentials = vi.fn();
+      const mockGetAccessToken = vi
+        .fn()
+        .mockResolvedValue({ token: 'cached-access-token' });
+      const mockGetTokenInfo = vi.fn().mockResolvedValue({});
+      const mockOAuth2Client = {
+        setCredentials: mockSetCredentials,
+        getAccessToken: mockGetAccessToken,
+        getTokenInfo: mockGetTokenInfo,
+        on: vi.fn(),
+      } as unknown as OAuth2Client;
+      (OAuth2Client as unknown as Mock).mockImplementation(
+        () => mockOAuth2Client,
+      );
+
+      // Make it fall through to cached credentials path
+      const cachedCreds = { refresh_token: 'cached-token' };
+      const credsPath = path.join(tempHomeDir, QWEN_DIR, 'oauth_creds.json');
+      await fs.promises.mkdir(path.dirname(credsPath), { recursive: true });
+      await fs.promises.writeFile(credsPath, JSON.stringify(cachedCreds));
+
+      await getOauthClient(AuthType.LOGIN_WITH_GOOGLE, mockConfig);
+
+      // It should be called with the cached credentials, not the GCP access token.
+      expect(mockSetCredentials).toHaveBeenCalledTimes(1);
+      expect(mockSetCredentials).toHaveBeenCalledWith(cachedCreds);
+    });
+  });
+  describe('clearCachedCredentialFile', () => {
+    it('should clear cached credentials and Google account', async () => {
+      const cachedCreds = { refresh_token: 'test-token' };
+      const credsPath = path.join(tempHomeDir, QWEN_DIR, 'oauth_creds.json');
+      await fs.promises.mkdir(path.dirname(credsPath), { recursive: true });
+      await fs.promises.writeFile(credsPath, JSON.stringify(cachedCreds));
+
+      const googleAccountPath = path.join(
+        tempHomeDir,
+        QWEN_DIR,
+        'google_accounts.json',
+      );
+      const accountData = { active: 'test@example.com', old: [] };
+      await fs.promises.writeFile(
+        googleAccountPath,
+        JSON.stringify(accountData),
+      );
+
+      expect(fs.existsSync(credsPath)).toBe(true);
+      expect(fs.existsSync(googleAccountPath)).toBe(true);
+      expect(getCachedGoogleAccount()).toBe('test@example.com');
+
+      await clearCachedCredentialFile();
+      expect(fs.existsSync(credsPath)).toBe(false);
+      expect(getCachedGoogleAccount()).toBeNull();
+      const updatedAccountData = JSON.parse(
+        fs.readFileSync(googleAccountPath, 'utf-8'),
+      );
+      expect(updatedAccountData.active).toBeNull();
+      expect(updatedAccountData.old).toContain('test@example.com');
+    });
+
+    it('should clear the in-memory OAuth client cache', async () => {
+      const mockSetCredentials = vi.fn();
+      const mockGetAccessToken = vi
+        .fn()
+        .mockResolvedValue({ token: 'test-token' });
+      const mockGetTokenInfo = vi.fn().mockResolvedValue({});
+      const mockOAuth2Client = {
+        setCredentials: mockSetCredentials,
+        getAccessToken: mockGetAccessToken,
+        getTokenInfo: mockGetTokenInfo,
+        on: vi.fn(),
+      } as unknown as OAuth2Client;
+      (OAuth2Client as unknown as Mock).mockImplementation(
+        () => mockOAuth2Client,
+      );
+
+      // Pre-populate credentials to make getOauthClient resolve quickly
+      const credsPath = path.join(tempHomeDir, QWEN_DIR, 'oauth_creds.json');
+      await fs.promises.mkdir(path.dirname(credsPath), { recursive: true });
+      await fs.promises.writeFile(
+        credsPath,
+        JSON.stringify({ refresh_token: 'token' }),
+      );
+
+      // First call, should create a client
+      await getOauthClient(AuthType.LOGIN_WITH_GOOGLE, mockConfig);
+      expect(OAuth2Client).toHaveBeenCalledTimes(1);
+
+      // Second call, should use cached client
+      await getOauthClient(AuthType.LOGIN_WITH_GOOGLE, mockConfig);
+      expect(OAuth2Client).toHaveBeenCalledTimes(1);
+
+      clearOauthClientCache();
+
+      // Third call, after clearing cache, should create a new client
+      await getOauthClient(AuthType.LOGIN_WITH_GOOGLE, mockConfig);
+      expect(OAuth2Client).toHaveBeenCalledTimes(2);
+    });
+  });
+});

projects/ui/qwen-code/packages/core/src/code_assist/oauth2.ts

@@ -0,0 +1,447 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import {
+  OAuth2Client,
+  Credentials,
+  Compute,
+  CodeChallengeMethod,
+} from 'google-auth-library';
+import * as http from 'http';
+import url from 'url';
+import crypto from 'crypto';
+import * as net from 'net';
+import open from 'open';
+import path from 'node:path';
+import { promises as fs } from 'node:fs';
+import * as os from 'os';
+import { Config } from '../config/config.js';
+import { getErrorMessage } from '../utils/errors.js';
+import {
+  cacheGoogleAccount,
+  getCachedGoogleAccount,
+  clearCachedGoogleAccount,
+} from '../utils/user_account.js';
+import { AuthType } from '../core/contentGenerator.js';
+import readline from 'node:readline';
+import { QWEN_DIR } from '../utils/paths.js';
+
+//  OAuth Client ID used to initiate OAuth2Client class.
+const OAUTH_CLIENT_ID =
+  '681255809395-oo8ft2oprdrnp9e3aqf6av3hmdib135j.apps.googleusercontent.com';
+
+// OAuth Secret value used to initiate OAuth2Client class.
+// Note: It's ok to save this in git because this is an installed application
+// as described here: https://developers.google.com/identity/protocols/oauth2#installed
+// "The process results in a client ID and, in some cases, a client secret,
+// which you embed in the source code of your application. (In this context,
+// the client secret is obviously not treated as a secret.)"
+const OAUTH_CLIENT_SECRET = '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';
+
+// OAuth Scopes for Cloud Code authorization.
+const OAUTH_SCOPE = [
+  'https://www.googleapis.com/auth/cloud-platform',
+  'https://www.googleapis.com/auth/userinfo.email',
+  'https://www.googleapis.com/auth/userinfo.profile',
+];
+
+const HTTP_REDIRECT = 301;
+const SIGN_IN_SUCCESS_URL =
+  'https://developers.google.com/gemini-code-assist/auth_success_gemini';
+const SIGN_IN_FAILURE_URL =
+  'https://developers.google.com/gemini-code-assist/auth_failure_gemini';
+
+const CREDENTIAL_FILENAME = 'oauth_creds.json';
+
+/**
+ * An Authentication URL for updating the credentials of a Oauth2Client
+ * as well as a promise that will resolve when the credentials have
+ * been refreshed (or which throws error when refreshing credentials failed).
+ */
+export interface OauthWebLogin {
+  authUrl: string;
+  loginCompletePromise: Promise<void>;
+}
+
+const oauthClientPromises = new Map<AuthType, Promise<OAuth2Client>>();
+
+async function initOauthClient(
+  authType: AuthType,
+  config: Config,
+): Promise<OAuth2Client> {
+  const client = new OAuth2Client({
+    clientId: OAUTH_CLIENT_ID,
+    clientSecret: OAUTH_CLIENT_SECRET,
+    transporterOptions: {
+      proxy: config.getProxy(),
+    },
+  });
+
+  if (
+    process.env['GOOGLE_GENAI_USE_GCA'] &&
+    process.env['GOOGLE_CLOUD_ACCESS_TOKEN']
+  ) {
+    client.setCredentials({
+      access_token: process.env['GOOGLE_CLOUD_ACCESS_TOKEN'],
+    });
+    await fetchAndCacheUserInfo(client);
+    return client;
+  }
+
+  client.on('tokens', async (tokens: Credentials) => {
+    await cacheCredentials(tokens);
+  });
+
+  // If there are cached creds on disk, they always take precedence
+  if (await loadCachedCredentials(client)) {
+    // Found valid cached credentials.
+    // Check if we need to retrieve Google Account ID or Email
+    if (!getCachedGoogleAccount()) {
+      try {
+        await fetchAndCacheUserInfo(client);
+      } catch {
+        // Non-fatal, continue with existing auth.
+      }
+    }
+    console.log('Loaded cached credentials.');
+    return client;
+  }
+
+  // In Google Cloud Shell, we can use Application Default Credentials (ADC)
+  // provided via its metadata server to authenticate non-interactively using
+  // the identity of the user logged into Cloud Shell.
+  if (authType === AuthType.CLOUD_SHELL) {
+    try {
+      console.log("Attempting to authenticate via Cloud Shell VM's ADC.");
+      const computeClient = new Compute({
+        // We can leave this empty, since the metadata server will provide
+        // the service account email.
+      });
+      await computeClient.getAccessToken();
+      console.log('Authentication successful.');
+
+      // Do not cache creds in this case; note that Compute client will handle its own refresh
+      return computeClient;
+    } catch (e) {
+      throw new Error(
+        `Could not authenticate using Cloud Shell credentials. Please select a different authentication method or ensure you are in a properly configured environment. Error: ${getErrorMessage(
+          e,
+        )}`,
+      );
+    }
+  }
+
+  if (config.isBrowserLaunchSuppressed()) {
+    let success = false;
+    const maxRetries = 2;
+    for (let i = 0; !success && i < maxRetries; i++) {
+      success = await authWithUserCode(client);
+      if (!success) {
+        console.error(
+          '\nFailed to authenticate with user code.',
+          i === maxRetries - 1 ? '' : 'Retrying...\n',
+        );
+      }
+    }
+    if (!success) {
+      process.exit(1);
+    }
+  } else {
+    const webLogin = await authWithWeb(client);
+
+    console.log(
+      `\n\nCode Assist login required.\n` +
+        `Attempting to open authentication page in your browser.\n` +
+        `Otherwise navigate to:\n\n${webLogin.authUrl}\n\n`,
+    );
+    try {
+      // Attempt to open the authentication URL in the default browser.
+      // We do not use the `wait` option here because the main script's execution
+      // is already paused by `loginCompletePromise`, which awaits the server callback.
+      const childProcess = await open(webLogin.authUrl);
+
+      // IMPORTANT: Attach an error handler to the returned child process.
+      // Without this, if `open` fails to spawn a process (e.g., `xdg-open` is not found
+      // in a minimal Docker container), it will emit an unhandled 'error' event,
+      // causing the entire Node.js process to crash.
+      childProcess.on('error', (_) => {
+        console.error(
+          'Failed to open browser automatically. Please try running again with NO_BROWSER=true set.',
+        );
+        process.exit(1);
+      });
+    } catch (err) {
+      console.error(
+        'An unexpected error occurred while trying to open the browser:',
+        err,
+        '\nPlease try running again with NO_BROWSER=true set.',
+      );
+      process.exit(1);
+    }
+    console.log('Waiting for authentication...');
+
+    await webLogin.loginCompletePromise;
+  }
+
+  return client;
+}
+
+export async function getOauthClient(
+  authType: AuthType,
+  config: Config,
+): Promise<OAuth2Client> {
+  if (!oauthClientPromises.has(authType)) {
+    oauthClientPromises.set(authType, initOauthClient(authType, config));
+  }
+  return oauthClientPromises.get(authType)!;
+}
+
+async function authWithUserCode(client: OAuth2Client): Promise<boolean> {
+  const redirectUri = 'https://codeassist.google.com/authcode';
+  const codeVerifier = await client.generateCodeVerifierAsync();
+  const state = crypto.randomBytes(32).toString('hex');
+  const authUrl: string = client.generateAuthUrl({
+    redirect_uri: redirectUri,
+    access_type: 'offline',
+    scope: OAUTH_SCOPE,
+    code_challenge_method: CodeChallengeMethod.S256,
+    code_challenge: codeVerifier.codeChallenge,
+    state,
+  });
+  console.log('Please visit the following URL to authorize the application:');
+  console.log('');
+  console.log(authUrl);
+  console.log('');
+
+  const code = await new Promise<string>((resolve) => {
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout,
+    });
+    rl.question('Enter the authorization code: ', (code) => {
+      rl.close();
+      resolve(code.trim());
+    });
+  });
+
+  if (!code) {
+    console.error('Authorization code is required.');
+    return false;
+  }
+
+  try {
+    const { tokens } = await client.getToken({
+      code,
+      codeVerifier: codeVerifier.codeVerifier,
+      redirect_uri: redirectUri,
+    });
+    client.setCredentials(tokens);
+  } catch (_error) {
+    return false;
+  }
+  return true;
+}
+
+async function authWithWeb(client: OAuth2Client): Promise<OauthWebLogin> {
+  const port = await getAvailablePort();
+  // The hostname used for the HTTP server binding (e.g., '0.0.0.0' in Docker).
+  const host = process.env['OAUTH_CALLBACK_HOST'] || 'localhost';
+  // The `redirectUri` sent to Google's authorization server MUST use a loopback IP literal
+  // (i.e., 'localhost' or '127.0.0.1'). This is a strict security policy for credentials of
+  // type 'Desktop app' or 'Web application' (when using loopback flow) to mitigate
+  // authorization code interception attacks.
+  const redirectUri = `http://localhost:${port}/oauth2callback`;
+  const state = crypto.randomBytes(32).toString('hex');
+  const authUrl = client.generateAuthUrl({
+    redirect_uri: redirectUri,
+    access_type: 'offline',
+    scope: OAUTH_SCOPE,
+    state,
+  });
+
+  const loginCompletePromise = new Promise<void>((resolve, reject) => {
+    const server = http.createServer(async (req, res) => {
+      try {
+        if (req.url!.indexOf('/oauth2callback') === -1) {
+          res.writeHead(HTTP_REDIRECT, { Location: SIGN_IN_FAILURE_URL });
+          res.end();
+          reject(new Error('Unexpected request: ' + req.url));
+        }
+        // acquire the code from the querystring, and close the web server.
+        const qs = new url.URL(req.url!, 'http://localhost:3000').searchParams;
+        if (qs.get('error')) {
+          res.writeHead(HTTP_REDIRECT, { Location: SIGN_IN_FAILURE_URL });
+          res.end();
+
+          reject(new Error(`Error during authentication: ${qs.get('error')}`));
+        } else if (qs.get('state') !== state) {
+          res.end('State mismatch. Possible CSRF attack');
+
+          reject(new Error('State mismatch. Possible CSRF attack'));
+        } else if (qs.get('code')) {
+          const { tokens } = await client.getToken({
+            code: qs.get('code')!,
+            redirect_uri: redirectUri,
+          });
+          client.setCredentials(tokens);
+          // Retrieve and cache Google Account ID during authentication
+          try {
+            await fetchAndCacheUserInfo(client);
+          } catch (error) {
+            console.error(
+              'Failed to retrieve Google Account ID during authentication:',
+              error,
+            );
+            // Don't fail the auth flow if Google Account ID retrieval fails
+          }
+
+          res.writeHead(HTTP_REDIRECT, { Location: SIGN_IN_SUCCESS_URL });
+          res.end();
+          resolve();
+        } else {
+          reject(new Error('No code found in request'));
+        }
+      } catch (e) {
+        reject(e);
+      } finally {
+        server.close();
+      }
+    });
+    server.listen(port, host);
+  });
+
+  return {
+    authUrl,
+    loginCompletePromise,
+  };
+}
+
+export function getAvailablePort(): Promise<number> {
+  return new Promise((resolve, reject) => {
+    let port = 0;
+    try {
+      const portStr = process.env['OAUTH_CALLBACK_PORT'];
+      if (portStr) {
+        port = parseInt(portStr, 10);
+        if (isNaN(port) || port <= 0 || port > 65535) {
+          return reject(
+            new Error(`Invalid value for OAUTH_CALLBACK_PORT: "${portStr}"`),
+          );
+        }
+        return resolve(port);
+      }
+      const server = net.createServer();
+      server.listen(0, () => {
+        const address = server.address()! as net.AddressInfo;
+        port = address.port;
+      });
+      server.on('listening', () => {
+        server.close();
+        server.unref();
+      });
+      server.on('error', (e) => reject(e));
+      server.on('close', () => resolve(port));
+    } catch (e) {
+      reject(e);
+    }
+  });
+}
+
+async function loadCachedCredentials(client: OAuth2Client): Promise<boolean> {
+  const pathsToTry = [
+    getCachedCredentialPath(),
+    process.env['GOOGLE_APPLICATION_CREDENTIALS'],
+  ].filter((p): p is string => !!p);
+
+  for (const keyFile of pathsToTry) {
+    try {
+      const creds = await fs.readFile(keyFile, 'utf-8');
+      client.setCredentials(JSON.parse(creds));
+
+      // This will verify locally that the credentials look good.
+      const { token } = await client.getAccessToken();
+      if (!token) {
+        continue;
+      }
+
+      // This will check with the server to see if it hasn't been revoked.
+      await client.getTokenInfo(token);
+
+      return true;
+    } catch (_) {
+      // Ignore and try next path.
+    }
+  }
+
+  return false;
+}
+
+async function cacheCredentials(credentials: Credentials) {
+  const filePath = getCachedCredentialPath();
+  await fs.mkdir(path.dirname(filePath), { recursive: true });
+
+  const credString = JSON.stringify(credentials, null, 2);
+  await fs.writeFile(filePath, credString, { mode: 0o600 });
+}
+
+function getCachedCredentialPath(): string {
+  return path.join(os.homedir(), QWEN_DIR, CREDENTIAL_FILENAME);
+}
+
+export function clearOauthClientCache() {
+  oauthClientPromises.clear();
+}
+
+export async function clearCachedCredentialFile() {
+  try {
+    await fs.rm(getCachedCredentialPath(), { force: true });
+    // Clear the Google Account ID cache when credentials are cleared
+    await clearCachedGoogleAccount();
+    // Clear the in-memory OAuth client cache to force re-authentication
+    clearOauthClientCache();
+  } catch (e) {
+    console.error('Failed to clear cached credentials:', e);
+  }
+}
+
+async function fetchAndCacheUserInfo(client: OAuth2Client): Promise<void> {
+  try {
+    const { token } = await client.getAccessToken();
+    if (!token) {
+      return;
+    }
+
+    const response = await fetch(
+      'https://www.googleapis.com/oauth2/v2/userinfo',
+      {
+        headers: {
+          Authorization: `Bearer ${token}`,
+        },
+      },
+    );
+
+    if (!response.ok) {
+      console.error(
+        'Failed to fetch user info:',
+        response.status,
+        response.statusText,
+      );
+      return;
+    }
+
+    const userInfo = await response.json();
+    if (userInfo.email) {
+      await cacheGoogleAccount(userInfo.email);
+    }
+  } catch (error) {
+    console.error('Error retrieving user info:', error);
+  }
+}
+
+// Helper to ensure test isolation
+export function resetOauthClientForTesting() {
+  oauthClientPromises.clear();
+}

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

@@ -0,0 +1,218 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { beforeEach, describe, it, expect, vi } from 'vitest';
+import { CodeAssistServer } from './server.js';
+import { OAuth2Client } from 'google-auth-library';
+import { UserTierId } from './types.js';
+
+vi.mock('google-auth-library');
+
+describe('CodeAssistServer', () => {
+  beforeEach(() => {
+    vi.resetAllMocks();
+  });
+
+  it('should be able to be constructed', () => {
+    const auth = new OAuth2Client();
+    const server = new CodeAssistServer(
+      auth,
+      'test-project',
+      {},
+      'test-session',
+      UserTierId.FREE,
+    );
+    expect(server).toBeInstanceOf(CodeAssistServer);
+  });
+
+  it('should call the generateContent endpoint', async () => {
+    const client = new OAuth2Client();
+    const server = new CodeAssistServer(
+      client,
+      'test-project',
+      {},
+      'test-session',
+      UserTierId.FREE,
+    );
+    const mockResponse = {
+      response: {
+        candidates: [
+          {
+            index: 0,
+            content: {
+              role: 'model',
+              parts: [{ text: 'response' }],
+            },
+            finishReason: 'STOP',
+            safetyRatings: [],
+          },
+        ],
+      },
+    };
+    vi.spyOn(server, 'requestPost').mockResolvedValue(mockResponse);
+
+    const response = await server.generateContent(
+      {
+        model: 'test-model',
+        contents: [{ role: 'user', parts: [{ text: 'request' }] }],
+      },
+      'user-prompt-id',
+    );
+
+    expect(server.requestPost).toHaveBeenCalledWith(
+      'generateContent',
+      expect.any(Object),
+      undefined,
+    );
+    expect(response.candidates?.[0]?.content?.parts?.[0]?.text).toBe(
+      'response',
+    );
+  });
+
+  it('should call the generateContentStream endpoint', async () => {
+    const client = new OAuth2Client();
+    const server = new CodeAssistServer(
+      client,
+      'test-project',
+      {},
+      'test-session',
+      UserTierId.FREE,
+    );
+    const mockResponse = (async function* () {
+      yield {
+        response: {
+          candidates: [
+            {
+              index: 0,
+              content: {
+                role: 'model',
+                parts: [{ text: 'response' }],
+              },
+              finishReason: 'STOP',
+              safetyRatings: [],
+            },
+          ],
+        },
+      };
+    })();
+    vi.spyOn(server, 'requestStreamingPost').mockResolvedValue(mockResponse);
+
+    const stream = await server.generateContentStream(
+      {
+        model: 'test-model',
+        contents: [{ role: 'user', parts: [{ text: 'request' }] }],
+      },
+      'user-prompt-id',
+    );
+
+    for await (const res of stream) {
+      expect(server.requestStreamingPost).toHaveBeenCalledWith(
+        'streamGenerateContent',
+        expect.any(Object),
+        undefined,
+      );
+      expect(res.candidates?.[0]?.content?.parts?.[0]?.text).toBe('response');
+    }
+  });
+
+  it('should call the onboardUser endpoint', async () => {
+    const client = new OAuth2Client();
+    const server = new CodeAssistServer(
+      client,
+      'test-project',
+      {},
+      'test-session',
+      UserTierId.FREE,
+    );
+    const mockResponse = {
+      name: 'operations/123',
+      done: true,
+    };
+    vi.spyOn(server, 'requestPost').mockResolvedValue(mockResponse);
+
+    const response = await server.onboardUser({
+      tierId: 'test-tier',
+      cloudaicompanionProject: 'test-project',
+      metadata: {},
+    });
+
+    expect(server.requestPost).toHaveBeenCalledWith(
+      'onboardUser',
+      expect.any(Object),
+    );
+    expect(response.name).toBe('operations/123');
+  });
+
+  it('should call the loadCodeAssist endpoint', async () => {
+    const client = new OAuth2Client();
+    const server = new CodeAssistServer(
+      client,
+      'test-project',
+      {},
+      'test-session',
+      UserTierId.FREE,
+    );
+    const mockResponse = {
+      currentTier: {
+        id: UserTierId.FREE,
+        name: 'Free',
+        description: 'free tier',
+      },
+      allowedTiers: [],
+      ineligibleTiers: [],
+      cloudaicompanionProject: 'projects/test',
+    };
+    vi.spyOn(server, 'requestPost').mockResolvedValue(mockResponse);
+
+    const response = await server.loadCodeAssist({
+      metadata: {},
+    });
+
+    expect(server.requestPost).toHaveBeenCalledWith(
+      'loadCodeAssist',
+      expect.any(Object),
+    );
+    expect(response).toEqual(mockResponse);
+  });
+
+  it('should return 0 for countTokens', async () => {
+    const client = new OAuth2Client();
+    const server = new CodeAssistServer(
+      client,
+      'test-project',
+      {},
+      'test-session',
+      UserTierId.FREE,
+    );
+    const mockResponse = {
+      totalTokens: 100,
+    };
+    vi.spyOn(server, 'requestPost').mockResolvedValue(mockResponse);
+
+    const response = await server.countTokens({
+      model: 'test-model',
+      contents: [{ role: 'user', parts: [{ text: 'request' }] }],
+    });
+    expect(response.totalTokens).toBe(100);
+  });
+
+  it('should throw an error for embedContent', async () => {
+    const client = new OAuth2Client();
+    const server = new CodeAssistServer(
+      client,
+      'test-project',
+      {},
+      'test-session',
+      UserTierId.FREE,
+    );
+    await expect(
+      server.embedContent({
+        model: 'test-model',
+        contents: [{ role: 'user', parts: [{ text: 'request' }] }],
+      }),
+    ).rejects.toThrow();
+  });
+});

projects/ui/qwen-code/packages/core/src/code_assist/server.ts

@@ -0,0 +1,221 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { OAuth2Client } from 'google-auth-library';
+import {
+  CodeAssistGlobalUserSettingResponse,
+  LoadCodeAssistRequest,
+  LoadCodeAssistResponse,
+  LongRunningOperationResponse,
+  OnboardUserRequest,
+  SetCodeAssistGlobalUserSettingRequest,
+} from './types.js';
+import {
+  CountTokensParameters,
+  CountTokensResponse,
+  EmbedContentParameters,
+  EmbedContentResponse,
+  GenerateContentParameters,
+  GenerateContentResponse,
+} from '@google/genai';
+import * as readline from 'readline';
+import { ContentGenerator } from '../core/contentGenerator.js';
+import { UserTierId } from './types.js';
+import {
+  CaCountTokenResponse,
+  CaGenerateContentResponse,
+  fromCountTokenResponse,
+  fromGenerateContentResponse,
+  toCountTokenRequest,
+  toGenerateContentRequest,
+} from './converter.js';
+
+/** HTTP options to be used in each of the requests. */
+export interface HttpOptions {
+  /** Additional HTTP headers to be sent with the request. */
+  headers?: Record<string, string>;
+}
+
+export const CODE_ASSIST_ENDPOINT = 'https://localhost:0'; // Disable Google Code Assist API Request
+export const CODE_ASSIST_API_VERSION = 'v1internal';
+
+export class CodeAssistServer implements ContentGenerator {
+  constructor(
+    readonly client: OAuth2Client,
+    readonly projectId?: string,
+    readonly httpOptions: HttpOptions = {},
+    readonly sessionId?: string,
+    readonly userTier?: UserTierId,
+  ) {}
+
+  async generateContentStream(
+    req: GenerateContentParameters,
+    userPromptId: string,
+  ): Promise<AsyncGenerator<GenerateContentResponse>> {
+    const resps = await this.requestStreamingPost<CaGenerateContentResponse>(
+      'streamGenerateContent',
+      toGenerateContentRequest(
+        req,
+        userPromptId,
+        this.projectId,
+        this.sessionId,
+      ),
+      req.config?.abortSignal,
+    );
+    return (async function* (): AsyncGenerator<GenerateContentResponse> {
+      for await (const resp of resps) {
+        yield fromGenerateContentResponse(resp);
+      }
+    })();
+  }
+
+  async generateContent(
+    req: GenerateContentParameters,
+    userPromptId: string,
+  ): Promise<GenerateContentResponse> {
+    const resp = await this.requestPost<CaGenerateContentResponse>(
+      'generateContent',
+      toGenerateContentRequest(
+        req,
+        userPromptId,
+        this.projectId,
+        this.sessionId,
+      ),
+      req.config?.abortSignal,
+    );
+    return fromGenerateContentResponse(resp);
+  }
+
+  async onboardUser(
+    req: OnboardUserRequest,
+  ): Promise<LongRunningOperationResponse> {
+    return await this.requestPost<LongRunningOperationResponse>(
+      'onboardUser',
+      req,
+    );
+  }
+
+  async loadCodeAssist(
+    req: LoadCodeAssistRequest,
+  ): Promise<LoadCodeAssistResponse> {
+    return await this.requestPost<LoadCodeAssistResponse>(
+      'loadCodeAssist',
+      req,
+    );
+  }
+
+  async getCodeAssistGlobalUserSetting(): Promise<CodeAssistGlobalUserSettingResponse> {
+    return await this.requestGet<CodeAssistGlobalUserSettingResponse>(
+      'getCodeAssistGlobalUserSetting',
+    );
+  }
+
+  async setCodeAssistGlobalUserSetting(
+    req: SetCodeAssistGlobalUserSettingRequest,
+  ): Promise<CodeAssistGlobalUserSettingResponse> {
+    return await this.requestPost<CodeAssistGlobalUserSettingResponse>(
+      'setCodeAssistGlobalUserSetting',
+      req,
+    );
+  }
+
+  async countTokens(req: CountTokensParameters): Promise<CountTokensResponse> {
+    const resp = await this.requestPost<CaCountTokenResponse>(
+      'countTokens',
+      toCountTokenRequest(req),
+    );
+    return fromCountTokenResponse(resp);
+  }
+
+  async embedContent(
+    _req: EmbedContentParameters,
+  ): Promise<EmbedContentResponse> {
+    throw Error();
+  }
+
+  async requestPost<T>(
+    method: string,
+    req: object,
+    signal?: AbortSignal,
+  ): Promise<T> {
+    const res = await this.client.request({
+      url: this.getMethodUrl(method),
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        ...this.httpOptions.headers,
+      },
+      responseType: 'json',
+      body: JSON.stringify(req),
+      signal,
+    });
+    return res.data as T;
+  }
+
+  async requestGet<T>(method: string, signal?: AbortSignal): Promise<T> {
+    const res = await this.client.request({
+      url: this.getMethodUrl(method),
+      method: 'GET',
+      headers: {
+        'Content-Type': 'application/json',
+        ...this.httpOptions.headers,
+      },
+      responseType: 'json',
+      signal,
+    });
+    return res.data as T;
+  }
+
+  async requestStreamingPost<T>(
+    method: string,
+    req: object,
+    signal?: AbortSignal,
+  ): Promise<AsyncGenerator<T>> {
+    const res = await this.client.request({
+      url: this.getMethodUrl(method),
+      method: 'POST',
+      params: {
+        alt: 'sse',
+      },
+      headers: {
+        'Content-Type': 'application/json',
+        ...this.httpOptions.headers,
+      },
+      responseType: 'stream',
+      body: JSON.stringify(req),
+      signal,
+    });
+
+    return (async function* (): AsyncGenerator<T> {
+      const rl = readline.createInterface({
+        input: res.data as NodeJS.ReadableStream,
+        crlfDelay: Infinity, // Recognizes '\r\n' and '\n' as line breaks
+      });
+
+      let bufferedLines: string[] = [];
+      for await (const line of rl) {
+        // blank lines are used to separate JSON objects in the stream
+        if (line === '') {
+          if (bufferedLines.length === 0) {
+            continue; // no data to yield
+          }
+          yield JSON.parse(bufferedLines.join('\n')) as T;
+          bufferedLines = []; // Reset the buffer after yielding
+        } else if (line.startsWith('data: ')) {
+          bufferedLines.push(line.slice(6).trim());
+        } else {
+          throw new Error(`Unexpected line format in response: ${line}`);
+        }
+      }
+    })();
+  }
+
+  getMethodUrl(method: string): string {
+    const endpoint =
+      process.env['CODE_ASSIST_ENDPOINT'] ?? CODE_ASSIST_ENDPOINT;
+    return `${endpoint}/${CODE_ASSIST_API_VERSION}:${method}`;
+  }
+}

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

@@ -0,0 +1,223 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { setupUser, ProjectIdRequiredError } from './setup.js';
+import { CodeAssistServer } from '../code_assist/server.js';
+import { OAuth2Client } from 'google-auth-library';
+import { GeminiUserTier, UserTierId } from './types.js';
+
+vi.mock('../code_assist/server.js');
+
+const mockPaidTier: GeminiUserTier = {
+  id: UserTierId.STANDARD,
+  name: 'paid',
+  description: 'Paid tier',
+  isDefault: true,
+};
+
+const mockFreeTier: GeminiUserTier = {
+  id: UserTierId.FREE,
+  name: 'free',
+  description: 'Free tier',
+  isDefault: true,
+};
+
+describe('setupUser for existing user', () => {
+  let mockLoad: ReturnType<typeof vi.fn>;
+  let mockOnboardUser: ReturnType<typeof vi.fn>;
+
+  beforeEach(() => {
+    vi.resetAllMocks();
+    mockLoad = vi.fn();
+    mockOnboardUser = vi.fn().mockResolvedValue({
+      done: true,
+      response: {
+        cloudaicompanionProject: {
+          id: 'server-project',
+        },
+      },
+    });
+    vi.mocked(CodeAssistServer).mockImplementation(
+      () =>
+        ({
+          loadCodeAssist: mockLoad,
+          onboardUser: mockOnboardUser,
+        }) as unknown as CodeAssistServer,
+    );
+  });
+
+  afterEach(() => {
+    vi.unstubAllEnvs();
+  });
+
+  it('should use GOOGLE_CLOUD_PROJECT when set and project from server is undefined', async () => {
+    vi.stubEnv('GOOGLE_CLOUD_PROJECT', 'test-project');
+    mockLoad.mockResolvedValue({
+      currentTier: mockPaidTier,
+    });
+    await setupUser({} as OAuth2Client);
+    expect(CodeAssistServer).toHaveBeenCalledWith(
+      {},
+      'test-project',
+      {},
+      '',
+      undefined,
+    );
+  });
+
+  it('should ignore GOOGLE_CLOUD_PROJECT when project from server is set', async () => {
+    vi.stubEnv('GOOGLE_CLOUD_PROJECT', 'test-project');
+    mockLoad.mockResolvedValue({
+      cloudaicompanionProject: 'server-project',
+      currentTier: mockPaidTier,
+    });
+    const projectId = await setupUser({} as OAuth2Client);
+    expect(CodeAssistServer).toHaveBeenCalledWith(
+      {},
+      'test-project',
+      {},
+      '',
+      undefined,
+    );
+    expect(projectId).toEqual({
+      projectId: 'server-project',
+      userTier: 'standard-tier',
+    });
+  });
+
+  it('should throw ProjectIdRequiredError when no project ID is available', async () => {
+    vi.stubEnv('GOOGLE_CLOUD_PROJECT', '');
+    // And the server itself requires a project ID internally
+    vi.mocked(CodeAssistServer).mockImplementation(() => {
+      throw new ProjectIdRequiredError();
+    });
+
+    await expect(setupUser({} as OAuth2Client)).rejects.toThrow(
+      ProjectIdRequiredError,
+    );
+  });
+});
+
+describe('setupUser for new user', () => {
+  let mockLoad: ReturnType<typeof vi.fn>;
+  let mockOnboardUser: ReturnType<typeof vi.fn>;
+
+  beforeEach(() => {
+    vi.resetAllMocks();
+    mockLoad = vi.fn();
+    mockOnboardUser = vi.fn().mockResolvedValue({
+      done: true,
+      response: {
+        cloudaicompanionProject: {
+          id: 'server-project',
+        },
+      },
+    });
+    vi.mocked(CodeAssistServer).mockImplementation(
+      () =>
+        ({
+          loadCodeAssist: mockLoad,
+          onboardUser: mockOnboardUser,
+        }) as unknown as CodeAssistServer,
+    );
+  });
+
+  afterEach(() => {
+    vi.unstubAllEnvs();
+  });
+
+  it('should use GOOGLE_CLOUD_PROJECT when set and onboard a new paid user', async () => {
+    vi.stubEnv('GOOGLE_CLOUD_PROJECT', 'test-project');
+    mockLoad.mockResolvedValue({
+      allowedTiers: [mockPaidTier],
+    });
+    const userData = await setupUser({} as OAuth2Client);
+    expect(CodeAssistServer).toHaveBeenCalledWith(
+      {},
+      'test-project',
+      {},
+      '',
+      undefined,
+    );
+    expect(mockLoad).toHaveBeenCalled();
+    expect(mockOnboardUser).toHaveBeenCalledWith({
+      tierId: 'standard-tier',
+      cloudaicompanionProject: 'test-project',
+      metadata: {
+        ideType: 'IDE_UNSPECIFIED',
+        platform: 'PLATFORM_UNSPECIFIED',
+        pluginType: 'GEMINI',
+        duetProject: 'test-project',
+      },
+    });
+    expect(userData).toEqual({
+      projectId: 'server-project',
+      userTier: 'standard-tier',
+    });
+  });
+
+  it('should onboard a new free user when GOOGLE_CLOUD_PROJECT is not set', async () => {
+    vi.stubEnv('GOOGLE_CLOUD_PROJECT', '');
+    mockLoad.mockResolvedValue({
+      allowedTiers: [mockFreeTier],
+    });
+    const userData = await setupUser({} as OAuth2Client);
+    expect(CodeAssistServer).toHaveBeenCalledWith(
+      {},
+      undefined,
+      {},
+      '',
+      undefined,
+    );
+    expect(mockLoad).toHaveBeenCalled();
+    expect(mockOnboardUser).toHaveBeenCalledWith({
+      tierId: 'free-tier',
+      cloudaicompanionProject: undefined,
+      metadata: {
+        ideType: 'IDE_UNSPECIFIED',
+        platform: 'PLATFORM_UNSPECIFIED',
+        pluginType: 'GEMINI',
+      },
+    });
+    expect(userData).toEqual({
+      projectId: 'server-project',
+      userTier: 'free-tier',
+    });
+  });
+
+  it('should use GOOGLE_CLOUD_PROJECT when onboard response has no project ID', async () => {
+    vi.stubEnv('GOOGLE_CLOUD_PROJECT', 'test-project');
+    mockLoad.mockResolvedValue({
+      allowedTiers: [mockPaidTier],
+    });
+    mockOnboardUser.mockResolvedValue({
+      done: true,
+      response: {
+        cloudaicompanionProject: undefined,
+      },
+    });
+    const userData = await setupUser({} as OAuth2Client);
+    expect(userData).toEqual({
+      projectId: 'test-project',
+      userTier: 'standard-tier',
+    });
+  });
+
+  it('should throw ProjectIdRequiredError when no project ID is available', async () => {
+    vi.stubEnv('GOOGLE_CLOUD_PROJECT', '');
+    mockLoad.mockResolvedValue({
+      allowedTiers: [mockPaidTier],
+    });
+    mockOnboardUser.mockResolvedValue({
+      done: true,
+      response: {},
+    });
+    await expect(setupUser({} as OAuth2Client)).rejects.toThrow(
+      ProjectIdRequiredError,
+    );
+  });
+});

projects/ui/qwen-code/packages/core/src/code_assist/setup.ts

@@ -0,0 +1,124 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import {
+  ClientMetadata,
+  GeminiUserTier,
+  LoadCodeAssistResponse,
+  OnboardUserRequest,
+  UserTierId,
+} from './types.js';
+import { CodeAssistServer } from './server.js';
+import { OAuth2Client } from 'google-auth-library';
+
+export class ProjectIdRequiredError extends Error {
+  constructor() {
+    super(
+      'This account requires setting the GOOGLE_CLOUD_PROJECT env var. See https://goo.gle/gemini-cli-auth-docs#workspace-gca',
+    );
+  }
+}
+
+export interface UserData {
+  projectId: string;
+  userTier: UserTierId;
+}
+
+/**
+ *
+ * @param projectId the user's project id, if any
+ * @returns the user's actual project id
+ */
+export async function setupUser(client: OAuth2Client): Promise<UserData> {
+  const projectId = process.env['GOOGLE_CLOUD_PROJECT'] || undefined;
+  const caServer = new CodeAssistServer(client, projectId, {}, '', undefined);
+  const coreClientMetadata: ClientMetadata = {
+    ideType: 'IDE_UNSPECIFIED',
+    platform: 'PLATFORM_UNSPECIFIED',
+    pluginType: 'GEMINI',
+  };
+
+  const loadRes = await caServer.loadCodeAssist({
+    cloudaicompanionProject: projectId,
+    metadata: {
+      ...coreClientMetadata,
+      duetProject: projectId,
+    },
+  });
+
+  if (loadRes.currentTier) {
+    if (!loadRes.cloudaicompanionProject) {
+      if (projectId) {
+        return {
+          projectId,
+          userTier: loadRes.currentTier.id,
+        };
+      }
+      throw new ProjectIdRequiredError();
+    }
+    return {
+      projectId: loadRes.cloudaicompanionProject,
+      userTier: loadRes.currentTier.id,
+    };
+  }
+
+  const tier = getOnboardTier(loadRes);
+
+  let onboardReq: OnboardUserRequest;
+  if (tier.id === UserTierId.FREE) {
+    // The free tier uses a managed google cloud project. Setting a project in the `onboardUser` request causes a `Precondition Failed` error.
+    onboardReq = {
+      tierId: tier.id,
+      cloudaicompanionProject: undefined,
+      metadata: coreClientMetadata,
+    };
+  } else {
+    onboardReq = {
+      tierId: tier.id,
+      cloudaicompanionProject: projectId,
+      metadata: {
+        ...coreClientMetadata,
+        duetProject: projectId,
+      },
+    };
+  }
+
+  // Poll onboardUser until long running operation is complete.
+  let lroRes = await caServer.onboardUser(onboardReq);
+  while (!lroRes.done) {
+    await new Promise((f) => setTimeout(f, 5000));
+    lroRes = await caServer.onboardUser(onboardReq);
+  }
+
+  if (!lroRes.response?.cloudaicompanionProject?.id) {
+    if (projectId) {
+      return {
+        projectId,
+        userTier: tier.id,
+      };
+    }
+    throw new ProjectIdRequiredError();
+  }
+
+  return {
+    projectId: lroRes.response.cloudaicompanionProject.id,
+    userTier: tier.id,
+  };
+}
+
+function getOnboardTier(res: LoadCodeAssistResponse): GeminiUserTier {
+  for (const tier of res.allowedTiers || []) {
+    if (tier.isDefault) {
+      return tier;
+    }
+  }
+  return {
+    name: '',
+    description: '',
+    id: UserTierId.LEGACY,
+    userDefinedCloudaicompanionProject: true,
+  };
+}

projects/ui/qwen-code/packages/core/src/code_assist/types.ts

@@ -0,0 +1,185 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+export interface ClientMetadata {
+  ideType?: ClientMetadataIdeType;
+  ideVersion?: string;
+  pluginVersion?: string;
+  platform?: ClientMetadataPlatform;
+  updateChannel?: string;
+  duetProject?: string;
+  pluginType?: ClientMetadataPluginType;
+  ideName?: string;
+}
+
+export type ClientMetadataIdeType =
+  | 'IDE_UNSPECIFIED'
+  | 'VSCODE'
+  | 'INTELLIJ'
+  | 'VSCODE_CLOUD_WORKSTATION'
+  | 'INTELLIJ_CLOUD_WORKSTATION'
+  | 'CLOUD_SHELL';
+export type ClientMetadataPlatform =
+  | 'PLATFORM_UNSPECIFIED'
+  | 'DARWIN_AMD64'
+  | 'DARWIN_ARM64'
+  | 'LINUX_AMD64'
+  | 'LINUX_ARM64'
+  | 'WINDOWS_AMD64';
+export type ClientMetadataPluginType =
+  | 'PLUGIN_UNSPECIFIED'
+  | 'CLOUD_CODE'
+  | 'GEMINI'
+  | 'AIPLUGIN_INTELLIJ'
+  | 'AIPLUGIN_STUDIO';
+
+export interface LoadCodeAssistRequest {
+  cloudaicompanionProject?: string;
+  metadata: ClientMetadata;
+}
+
+/**
+ * Represents LoadCodeAssistResponse proto json field
+ * http://google3/google/internal/cloud/code/v1internal/cloudcode.proto;l=224
+ */
+export interface LoadCodeAssistResponse {
+  currentTier?: GeminiUserTier | null;
+  allowedTiers?: GeminiUserTier[] | null;
+  ineligibleTiers?: IneligibleTier[] | null;
+  cloudaicompanionProject?: string | null;
+}
+
+/**
+ * GeminiUserTier reflects the structure received from the CodeAssist when calling LoadCodeAssist.
+ */
+export interface GeminiUserTier {
+  id: UserTierId;
+  name: string;
+  description: string;
+  // This value is used to declare whether a given tier requires the user to configure the project setting on the IDE settings or not.
+  userDefinedCloudaicompanionProject?: boolean | null;
+  isDefault?: boolean;
+  privacyNotice?: PrivacyNotice;
+  hasAcceptedTos?: boolean;
+  hasOnboardedPreviously?: boolean;
+}
+
+/**
+ * Includes information specifying the reasons for a user's ineligibility for a specific tier.
+ * @param reasonCode mnemonic code representing the reason for in-eligibility.
+ * @param reasonMessage message to display to the user.
+ * @param tierId id of the tier.
+ * @param tierName name of the tier.
+ */
+export interface IneligibleTier {
+  reasonCode: IneligibleTierReasonCode;
+  reasonMessage: string;
+  tierId: UserTierId;
+  tierName: string;
+}
+
+/**
+ * List of predefined reason codes when a tier is blocked from a specific tier.
+ * https://source.corp.google.com/piper///depot/google3/google/internal/cloud/code/v1internal/cloudcode.proto;l=378
+ */
+export enum IneligibleTierReasonCode {
+  // go/keep-sorted start
+  DASHER_USER = 'DASHER_USER',
+  INELIGIBLE_ACCOUNT = 'INELIGIBLE_ACCOUNT',
+  NON_USER_ACCOUNT = 'NON_USER_ACCOUNT',
+  RESTRICTED_AGE = 'RESTRICTED_AGE',
+  RESTRICTED_NETWORK = 'RESTRICTED_NETWORK',
+  UNKNOWN = 'UNKNOWN',
+  UNKNOWN_LOCATION = 'UNKNOWN_LOCATION',
+  UNSUPPORTED_LOCATION = 'UNSUPPORTED_LOCATION',
+  // go/keep-sorted end
+}
+/**
+ * UserTierId represents IDs returned from the Cloud Code Private API representing a user's tier
+ *
+ * //depot/google3/cloud/developer_experience/cloudcode/pa/service/usertier.go;l=16
+ */
+export enum UserTierId {
+  FREE = 'free-tier',
+  LEGACY = 'legacy-tier',
+  STANDARD = 'standard-tier',
+}
+
+/**
+ * PrivacyNotice reflects the structure received from the CodeAssist in regards to a tier
+ * privacy notice.
+ */
+export interface PrivacyNotice {
+  showNotice: boolean;
+  noticeText?: string;
+}
+
+/**
+ * Proto signature of OnboardUserRequest as payload to OnboardUser call
+ */
+export interface OnboardUserRequest {
+  tierId: string | undefined;
+  cloudaicompanionProject: string | undefined;
+  metadata: ClientMetadata | undefined;
+}
+
+/**
+ * Represents LongRunningOperation proto
+ * http://google3/google/longrunning/operations.proto;rcl=698857719;l=107
+ */
+export interface LongRunningOperationResponse {
+  name: string;
+  done?: boolean;
+  response?: OnboardUserResponse;
+}
+
+/**
+ * Represents OnboardUserResponse proto
+ * http://google3/google/internal/cloud/code/v1internal/cloudcode.proto;l=215
+ */
+export interface OnboardUserResponse {
+  // tslint:disable-next-line:enforce-name-casing This is the name of the field in the proto.
+  cloudaicompanionProject?: {
+    id: string;
+    name: string;
+  };
+}
+
+/**
+ * Status code of user license status
+ * it does not strictly correspond to the proto
+ * Error value is an additional value assigned to error responses from OnboardUser
+ */
+export enum OnboardUserStatusCode {
+  Default = 'DEFAULT',
+  Notice = 'NOTICE',
+  Warning = 'WARNING',
+  Error = 'ERROR',
+}
+
+/**
+ * Status of user onboarded to gemini
+ */
+export interface OnboardUserStatus {
+  statusCode: OnboardUserStatusCode;
+  displayMessage: string;
+  helpLink: HelpLinkUrl | undefined;
+}
+
+export interface HelpLinkUrl {
+  description: string;
+  url: string;
+}
+
+export interface SetCodeAssistGlobalUserSettingRequest {
+  cloudaicompanionProject?: string;
+  freeTierDataCollectionOptin: boolean;
+}
+
+export interface CodeAssistGlobalUserSettingResponse {
+  cloudaicompanionProject?: string;
+  freeTierDataCollectionOptin: boolean;
+}

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

@@ -0,0 +1,592 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { Mock } from 'vitest';
+import { Config, ConfigParameters, SandboxConfig } from './config.js';
+import * as path from 'path';
+import { setGeminiMdFilename as mockSetGeminiMdFilename } from '../tools/memoryTool.js';
+import {
+  DEFAULT_TELEMETRY_TARGET,
+  DEFAULT_OTLP_ENDPOINT,
+} from '../telemetry/index.js';
+import {
+  AuthType,
+  ContentGeneratorConfig,
+  createContentGeneratorConfig,
+} from '../core/contentGenerator.js';
+import { GeminiClient } from '../core/client.js';
+import { GitService } from '../services/gitService.js';
+
+vi.mock('fs', async (importOriginal) => {
+  const actual = await importOriginal<typeof import('fs')>();
+  return {
+    ...actual,
+    existsSync: vi.fn().mockReturnValue(true),
+    statSync: vi.fn().mockReturnValue({
+      isDirectory: vi.fn().mockReturnValue(true),
+    }),
+    realpathSync: vi.fn((path) => path),
+  };
+});
+
+vi.mock('fs', async (importOriginal) => {
+  const actual = await importOriginal<typeof import('fs')>();
+  return {
+    ...actual,
+    existsSync: vi.fn().mockReturnValue(true),
+    statSync: vi.fn().mockReturnValue({
+      isDirectory: vi.fn().mockReturnValue(true),
+    }),
+    realpathSync: vi.fn((path) => path),
+  };
+});
+
+// Mock dependencies that might be called during Config construction or createServerConfig
+vi.mock('../tools/tool-registry', () => {
+  const ToolRegistryMock = vi.fn();
+  ToolRegistryMock.prototype.registerTool = vi.fn();
+  ToolRegistryMock.prototype.discoverAllTools = vi.fn();
+  ToolRegistryMock.prototype.getAllTools = vi.fn(() => []); // Mock methods if needed
+  ToolRegistryMock.prototype.getTool = vi.fn();
+  ToolRegistryMock.prototype.getFunctionDeclarations = vi.fn(() => []);
+  return { ToolRegistry: ToolRegistryMock };
+});
+
+vi.mock('../utils/memoryDiscovery.js', () => ({
+  loadServerHierarchicalMemory: vi.fn(),
+}));
+
+// Mock individual tools if their constructors are complex or have side effects
+vi.mock('../tools/ls');
+vi.mock('../tools/read-file');
+vi.mock('../tools/grep');
+vi.mock('../tools/glob');
+vi.mock('../tools/edit');
+vi.mock('../tools/shell');
+vi.mock('../tools/write-file');
+vi.mock('../tools/web-fetch');
+vi.mock('../tools/read-many-files');
+vi.mock('../tools/memoryTool', () => ({
+  MemoryTool: vi.fn(),
+  setGeminiMdFilename: vi.fn(),
+  getCurrentGeminiMdFilename: vi.fn(() => 'QWEN.md'), // Mock the original filename
+  DEFAULT_CONTEXT_FILENAME: 'QWEN.md',
+  GEMINI_CONFIG_DIR: '.gemini',
+}));
+
+vi.mock('../core/contentGenerator.js', async (importOriginal) => {
+  const actual =
+    await importOriginal<typeof import('../core/contentGenerator.js')>();
+  return {
+    ...actual,
+    createContentGeneratorConfig: vi.fn(),
+  };
+});
+
+vi.mock('../core/client.js', () => ({
+  GeminiClient: vi.fn().mockImplementation(() => ({
+    initialize: vi.fn().mockResolvedValue(undefined),
+  })),
+}));
+
+vi.mock('../telemetry/index.js', async (importOriginal) => {
+  const actual = await importOriginal<typeof import('../telemetry/index.js')>();
+  return {
+    ...actual,
+    initializeTelemetry: vi.fn(),
+  };
+});
+
+vi.mock('../services/gitService.js', () => {
+  const GitServiceMock = vi.fn();
+  GitServiceMock.prototype.initialize = vi.fn();
+  return { GitService: GitServiceMock };
+});
+
+describe('Server Config (config.ts)', () => {
+  const MODEL = 'gemini-pro';
+  const SANDBOX: SandboxConfig = {
+    command: 'docker',
+    image: 'qwen-code-sandbox',
+  };
+  const TARGET_DIR = '/path/to/target';
+  const DEBUG_MODE = false;
+  const QUESTION = 'test question';
+  const FULL_CONTEXT = false;
+  const USER_MEMORY = 'Test User Memory';
+  const TELEMETRY_SETTINGS = { enabled: false };
+  const EMBEDDING_MODEL = 'gemini-embedding';
+  const SESSION_ID = 'test-session-id';
+  const baseParams: ConfigParameters = {
+    cwd: '/tmp',
+    embeddingModel: EMBEDDING_MODEL,
+    sandbox: SANDBOX,
+    targetDir: TARGET_DIR,
+    debugMode: DEBUG_MODE,
+    question: QUESTION,
+    fullContext: FULL_CONTEXT,
+    userMemory: USER_MEMORY,
+    telemetry: TELEMETRY_SETTINGS,
+    sessionId: SESSION_ID,
+    model: MODEL,
+    usageStatisticsEnabled: false,
+  };
+
+  beforeEach(() => {
+    // Reset mocks if necessary
+    vi.clearAllMocks();
+  });
+
+  describe('initialize', () => {
+    it('should throw an error if checkpointing is enabled and GitService fails', async () => {
+      const gitError = new Error('Git is not installed');
+      (GitService.prototype.initialize as Mock).mockRejectedValue(gitError);
+
+      const config = new Config({
+        ...baseParams,
+        checkpointing: true,
+      });
+
+      await expect(config.initialize()).rejects.toThrow(gitError);
+    });
+
+    it('should not throw an error if checkpointing is disabled and GitService fails', async () => {
+      const gitError = new Error('Git is not installed');
+      (GitService.prototype.initialize as Mock).mockRejectedValue(gitError);
+
+      const config = new Config({
+        ...baseParams,
+        checkpointing: false,
+      });
+
+      await expect(config.initialize()).resolves.toBeUndefined();
+    });
+
+    it('should throw an error if initialized more than once', async () => {
+      const config = new Config({
+        ...baseParams,
+        checkpointing: false,
+      });
+
+      await expect(config.initialize()).resolves.toBeUndefined();
+      await expect(config.initialize()).rejects.toThrow(
+        'Config was already initialized',
+      );
+    });
+  });
+
+  describe('refreshAuth', () => {
+    it('should refresh auth and update config', async () => {
+      const config = new Config(baseParams);
+      const authType = AuthType.USE_GEMINI;
+      const newModel = 'gemini-flash';
+      const mockContentConfig = {
+        model: newModel,
+        apiKey: 'test-key',
+      };
+
+      (createContentGeneratorConfig as Mock).mockReturnValue(mockContentConfig);
+
+      // Set fallback mode to true to ensure it gets reset
+      config.setFallbackMode(true);
+      expect(config.isInFallbackMode()).toBe(true);
+
+      await config.refreshAuth(authType);
+
+      expect(createContentGeneratorConfig).toHaveBeenCalledWith(
+        config,
+        authType,
+      );
+      // Verify that contentGeneratorConfig is updated with the new model
+      expect(config.getContentGeneratorConfig()).toEqual(mockContentConfig);
+      expect(config.getContentGeneratorConfig().model).toBe(newModel);
+      expect(config.getModel()).toBe(newModel); // getModel() should return the updated model
+      expect(GeminiClient).toHaveBeenCalledWith(config);
+      // Verify that fallback mode is reset
+      expect(config.isInFallbackMode()).toBe(false);
+    });
+
+    it('should preserve conversation history when refreshing auth', async () => {
+      const config = new Config(baseParams);
+      const authType = AuthType.USE_GEMINI;
+      const mockContentConfig = {
+        model: 'gemini-pro',
+        apiKey: 'test-key',
+      };
+
+      (createContentGeneratorConfig as Mock).mockReturnValue(mockContentConfig);
+
+      // Mock the existing client with some history
+      const mockExistingHistory = [
+        { role: 'user', parts: [{ text: 'Hello' }] },
+        { role: 'model', parts: [{ text: 'Hi there!' }] },
+        { role: 'user', parts: [{ text: 'How are you?' }] },
+      ];
+
+      const mockExistingClient = {
+        isInitialized: vi.fn().mockReturnValue(true),
+        getHistory: vi.fn().mockReturnValue(mockExistingHistory),
+      };
+
+      const mockNewClient = {
+        isInitialized: vi.fn().mockReturnValue(true),
+        getHistory: vi.fn().mockReturnValue([]),
+        setHistory: vi.fn(),
+        initialize: vi.fn().mockResolvedValue(undefined),
+      };
+
+      // Set the existing client
+      (
+        config as unknown as { geminiClient: typeof mockExistingClient }
+      ).geminiClient = mockExistingClient;
+      (GeminiClient as Mock).mockImplementation(() => mockNewClient);
+
+      await config.refreshAuth(authType);
+
+      // Verify that existing history was retrieved
+      expect(mockExistingClient.getHistory).toHaveBeenCalled();
+
+      // Verify that new client was created and initialized
+      expect(GeminiClient).toHaveBeenCalledWith(config);
+      expect(mockNewClient.initialize).toHaveBeenCalledWith(mockContentConfig);
+
+      // Verify that history was restored to the new client
+      expect(mockNewClient.setHistory).toHaveBeenCalledWith(
+        mockExistingHistory,
+        { stripThoughts: false },
+      );
+    });
+
+    it('should handle case when no existing client is initialized', async () => {
+      const config = new Config(baseParams);
+      const authType = AuthType.USE_GEMINI;
+      const mockContentConfig = {
+        model: 'gemini-pro',
+        apiKey: 'test-key',
+      };
+
+      (createContentGeneratorConfig as Mock).mockReturnValue(mockContentConfig);
+
+      const mockNewClient = {
+        isInitialized: vi.fn().mockReturnValue(true),
+        getHistory: vi.fn().mockReturnValue([]),
+        setHistory: vi.fn(),
+        initialize: vi.fn().mockResolvedValue(undefined),
+      };
+
+      // No existing client
+      (config as unknown as { geminiClient: null }).geminiClient = null;
+      (GeminiClient as Mock).mockImplementation(() => mockNewClient);
+
+      await config.refreshAuth(authType);
+
+      // Verify that new client was created and initialized
+      expect(GeminiClient).toHaveBeenCalledWith(config);
+      expect(mockNewClient.initialize).toHaveBeenCalledWith(mockContentConfig);
+
+      // Verify that setHistory was not called since there was no existing history
+      expect(mockNewClient.setHistory).not.toHaveBeenCalled();
+    });
+
+    it('should strip thoughts when switching from GenAI to Vertex', async () => {
+      const config = new Config(baseParams);
+      const mockContentConfig = {
+        model: 'gemini-pro',
+        apiKey: 'test-key',
+        authType: AuthType.USE_GEMINI,
+      };
+      (
+        config as unknown as { contentGeneratorConfig: ContentGeneratorConfig }
+      ).contentGeneratorConfig = mockContentConfig;
+
+      (createContentGeneratorConfig as Mock).mockReturnValue({
+        ...mockContentConfig,
+        authType: AuthType.LOGIN_WITH_GOOGLE,
+      });
+
+      const mockExistingHistory = [
+        { role: 'user', parts: [{ text: 'Hello' }] },
+      ];
+      const mockExistingClient = {
+        isInitialized: vi.fn().mockReturnValue(true),
+        getHistory: vi.fn().mockReturnValue(mockExistingHistory),
+      };
+      const mockNewClient = {
+        isInitialized: vi.fn().mockReturnValue(true),
+        getHistory: vi.fn().mockReturnValue([]),
+        setHistory: vi.fn(),
+        initialize: vi.fn().mockResolvedValue(undefined),
+      };
+
+      (
+        config as unknown as { geminiClient: typeof mockExistingClient }
+      ).geminiClient = mockExistingClient;
+      (GeminiClient as Mock).mockImplementation(() => mockNewClient);
+
+      await config.refreshAuth(AuthType.LOGIN_WITH_GOOGLE);
+
+      expect(mockNewClient.setHistory).toHaveBeenCalledWith(
+        mockExistingHistory,
+        { stripThoughts: true },
+      );
+    });
+
+    it('should not strip thoughts when switching from Vertex to GenAI', async () => {
+      const config = new Config(baseParams);
+      const mockContentConfig = {
+        model: 'gemini-pro',
+        apiKey: 'test-key',
+        authType: AuthType.LOGIN_WITH_GOOGLE,
+      };
+      (
+        config as unknown as { contentGeneratorConfig: ContentGeneratorConfig }
+      ).contentGeneratorConfig = mockContentConfig;
+
+      (createContentGeneratorConfig as Mock).mockReturnValue({
+        ...mockContentConfig,
+        authType: AuthType.USE_GEMINI,
+      });
+
+      const mockExistingHistory = [
+        { role: 'user', parts: [{ text: 'Hello' }] },
+      ];
+      const mockExistingClient = {
+        isInitialized: vi.fn().mockReturnValue(true),
+        getHistory: vi.fn().mockReturnValue(mockExistingHistory),
+      };
+      const mockNewClient = {
+        isInitialized: vi.fn().mockReturnValue(true),
+        getHistory: vi.fn().mockReturnValue([]),
+        setHistory: vi.fn(),
+        initialize: vi.fn().mockResolvedValue(undefined),
+      };
+
+      (
+        config as unknown as { geminiClient: typeof mockExistingClient }
+      ).geminiClient = mockExistingClient;
+      (GeminiClient as Mock).mockImplementation(() => mockNewClient);
+
+      await config.refreshAuth(AuthType.USE_GEMINI);
+
+      expect(mockNewClient.setHistory).toHaveBeenCalledWith(
+        mockExistingHistory,
+        { stripThoughts: false },
+      );
+    });
+  });
+
+  it('Config constructor should store userMemory correctly', () => {
+    const config = new Config(baseParams);
+
+    expect(config.getUserMemory()).toBe(USER_MEMORY);
+    // Verify other getters if needed
+    expect(config.getTargetDir()).toBe(path.resolve(TARGET_DIR)); // Check resolved path
+  });
+
+  it('Config constructor should default userMemory to empty string if not provided', () => {
+    const paramsWithoutMemory: ConfigParameters = { ...baseParams };
+    delete paramsWithoutMemory.userMemory;
+    const config = new Config(paramsWithoutMemory);
+
+    expect(config.getUserMemory()).toBe('');
+  });
+
+  it('Config constructor should call setGeminiMdFilename with contextFileName if provided', () => {
+    const contextFileName = 'CUSTOM_AGENTS.md';
+    const paramsWithContextFile: ConfigParameters = {
+      ...baseParams,
+      contextFileName,
+    };
+    new Config(paramsWithContextFile);
+    expect(mockSetGeminiMdFilename).toHaveBeenCalledWith(contextFileName);
+  });
+
+  it('Config constructor should not call setGeminiMdFilename if contextFileName is not provided', () => {
+    new Config(baseParams); // baseParams does not have contextFileName
+    expect(mockSetGeminiMdFilename).not.toHaveBeenCalled();
+  });
+
+  it('should set default file filtering settings when not provided', () => {
+    const config = new Config(baseParams);
+    expect(config.getFileFilteringRespectGitIgnore()).toBe(true);
+  });
+
+  it('should set custom file filtering settings when provided', () => {
+    const paramsWithFileFiltering: ConfigParameters = {
+      ...baseParams,
+      fileFiltering: {
+        respectGitIgnore: false,
+      },
+    };
+    const config = new Config(paramsWithFileFiltering);
+    expect(config.getFileFilteringRespectGitIgnore()).toBe(false);
+  });
+
+  it('should initialize WorkspaceContext with includeDirectories', () => {
+    const includeDirectories = ['/path/to/dir1', '/path/to/dir2'];
+    const paramsWithIncludeDirs: ConfigParameters = {
+      ...baseParams,
+      includeDirectories,
+    };
+    const config = new Config(paramsWithIncludeDirs);
+    const workspaceContext = config.getWorkspaceContext();
+    const directories = workspaceContext.getDirectories();
+
+    // Should include the target directory plus the included directories
+    expect(directories).toHaveLength(3);
+    expect(directories).toContain(path.resolve(baseParams.targetDir));
+    expect(directories).toContain('/path/to/dir1');
+    expect(directories).toContain('/path/to/dir2');
+  });
+
+  it('Config constructor should set telemetry to true when provided as true', () => {
+    const paramsWithTelemetry: ConfigParameters = {
+      ...baseParams,
+      telemetry: { enabled: true },
+    };
+    const config = new Config(paramsWithTelemetry);
+    expect(config.getTelemetryEnabled()).toBe(true);
+  });
+
+  it('Config constructor should set telemetry to false when provided as false', () => {
+    const paramsWithTelemetry: ConfigParameters = {
+      ...baseParams,
+      telemetry: { enabled: false },
+    };
+    const config = new Config(paramsWithTelemetry);
+    expect(config.getTelemetryEnabled()).toBe(false);
+  });
+
+  it('Config constructor should default telemetry to default value if not provided', () => {
+    const paramsWithoutTelemetry: ConfigParameters = { ...baseParams };
+    delete paramsWithoutTelemetry.telemetry;
+    const config = new Config(paramsWithoutTelemetry);
+    expect(config.getTelemetryEnabled()).toBe(TELEMETRY_SETTINGS.enabled);
+  });
+
+  it('should have a getFileService method that returns FileDiscoveryService', () => {
+    const config = new Config(baseParams);
+    const fileService = config.getFileService();
+    expect(fileService).toBeDefined();
+  });
+
+  describe('Usage Statistics', () => {
+    it('defaults usage statistics to enabled if not specified', () => {
+      const config = new Config({
+        ...baseParams,
+        usageStatisticsEnabled: undefined,
+      });
+
+      expect(config.getUsageStatisticsEnabled()).toBe(true);
+    });
+
+    it.each([{ enabled: true }, { enabled: false }])(
+      'sets usage statistics based on the provided value (enabled: $enabled)',
+      ({ enabled }) => {
+        const config = new Config({
+          ...baseParams,
+          usageStatisticsEnabled: enabled,
+        });
+        expect(config.getUsageStatisticsEnabled()).toBe(enabled);
+      },
+    );
+  });
+
+  describe('Telemetry Settings', () => {
+    it('should return default telemetry target if not provided', () => {
+      const params: ConfigParameters = {
+        ...baseParams,
+        telemetry: { enabled: true },
+      };
+      const config = new Config(params);
+      expect(config.getTelemetryTarget()).toBe(DEFAULT_TELEMETRY_TARGET);
+    });
+
+    it('should return provided OTLP endpoint', () => {
+      const endpoint = 'http://custom.otel.collector:4317';
+      const params: ConfigParameters = {
+        ...baseParams,
+        telemetry: { enabled: true, otlpEndpoint: endpoint },
+      };
+      const config = new Config(params);
+      expect(config.getTelemetryOtlpEndpoint()).toBe(endpoint);
+    });
+
+    it('should return default OTLP endpoint if not provided', () => {
+      const params: ConfigParameters = {
+        ...baseParams,
+        telemetry: { enabled: true },
+      };
+      const config = new Config(params);
+      expect(config.getTelemetryOtlpEndpoint()).toBe(DEFAULT_OTLP_ENDPOINT);
+    });
+
+    it('should return provided logPrompts setting', () => {
+      const params: ConfigParameters = {
+        ...baseParams,
+        telemetry: { enabled: true, logPrompts: false },
+      };
+      const config = new Config(params);
+      expect(config.getTelemetryLogPromptsEnabled()).toBe(false);
+    });
+
+    it('should return default logPrompts setting (true) if not provided', () => {
+      const params: ConfigParameters = {
+        ...baseParams,
+        telemetry: { enabled: true },
+      };
+      const config = new Config(params);
+      expect(config.getTelemetryLogPromptsEnabled()).toBe(true);
+    });
+
+    it('should return default logPrompts setting (true) if telemetry object is not provided', () => {
+      const paramsWithoutTelemetry: ConfigParameters = { ...baseParams };
+      delete paramsWithoutTelemetry.telemetry;
+      const config = new Config(paramsWithoutTelemetry);
+      expect(config.getTelemetryLogPromptsEnabled()).toBe(true);
+    });
+
+    it('should return default telemetry target if telemetry object is not provided', () => {
+      const paramsWithoutTelemetry: ConfigParameters = { ...baseParams };
+      delete paramsWithoutTelemetry.telemetry;
+      const config = new Config(paramsWithoutTelemetry);
+      expect(config.getTelemetryTarget()).toBe(DEFAULT_TELEMETRY_TARGET);
+    });
+
+    it('should return default OTLP endpoint if telemetry object is not provided', () => {
+      const paramsWithoutTelemetry: ConfigParameters = { ...baseParams };
+      delete paramsWithoutTelemetry.telemetry;
+      const config = new Config(paramsWithoutTelemetry);
+      expect(config.getTelemetryOtlpEndpoint()).toBe(DEFAULT_OTLP_ENDPOINT);
+    });
+
+    it('should return provided OTLP protocol', () => {
+      const params: ConfigParameters = {
+        ...baseParams,
+        telemetry: { enabled: true, otlpProtocol: 'http' },
+      };
+      const config = new Config(params);
+      expect(config.getTelemetryOtlpProtocol()).toBe('http');
+    });
+
+    it('should return default OTLP protocol if not provided', () => {
+      const params: ConfigParameters = {
+        ...baseParams,
+        telemetry: { enabled: true },
+      };
+      const config = new Config(params);
+      expect(config.getTelemetryOtlpProtocol()).toBe('grpc');
+    });
+
+    it('should return default OTLP protocol if telemetry object is not provided', () => {
+      const paramsWithoutTelemetry: ConfigParameters = { ...baseParams };
+      delete paramsWithoutTelemetry.telemetry;
+      const config = new Config(paramsWithoutTelemetry);
+      expect(config.getTelemetryOtlpProtocol()).toBe('grpc');
+    });
+  });
+});

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

@@ -0,0 +1,919 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import * as path from 'node:path';
+import process from 'node:process';
+import {
+  AuthType,
+  ContentGeneratorConfig,
+  createContentGeneratorConfig,
+} from '../core/contentGenerator.js';
+import { PromptRegistry } from '../prompts/prompt-registry.js';
+import { ToolRegistry } from '../tools/tool-registry.js';
+import { LSTool } from '../tools/ls.js';
+import { ReadFileTool } from '../tools/read-file.js';
+import { GrepTool } from '../tools/grep.js';
+import { GlobTool } from '../tools/glob.js';
+import { EditTool } from '../tools/edit.js';
+import { ShellTool } from '../tools/shell.js';
+import { WriteFileTool } from '../tools/write-file.js';
+import { WebFetchTool } from '../tools/web-fetch.js';
+import { ReadManyFilesTool } from '../tools/read-many-files.js';
+import {
+  MemoryTool,
+  setGeminiMdFilename,
+  GEMINI_CONFIG_DIR as GEMINI_DIR,
+} from '../tools/memoryTool.js';
+import { TodoWriteTool } from '../tools/todoWrite.js';
+import { WebSearchTool } from '../tools/web-search.js';
+import { GeminiClient } from '../core/client.js';
+import { FileDiscoveryService } from '../services/fileDiscoveryService.js';
+import { GitService } from '../services/gitService.js';
+import { getProjectTempDir } from '../utils/paths.js';
+import {
+  initializeTelemetry,
+  DEFAULT_TELEMETRY_TARGET,
+  DEFAULT_OTLP_ENDPOINT,
+  TelemetryTarget,
+  StartSessionEvent,
+} from '../telemetry/index.js';
+import {
+  DEFAULT_GEMINI_EMBEDDING_MODEL,
+  DEFAULT_GEMINI_FLASH_MODEL,
+} from './models.js';
+import { shouldAttemptBrowserLaunch } from '../utils/browser.js';
+import { MCPOAuthConfig } from '../mcp/oauth-provider.js';
+import { IdeClient } from '../ide/ide-client.js';
+import type { Content } from '@google/genai';
+import {
+  FileSystemService,
+  StandardFileSystemService,
+} from '../services/fileSystemService.js';
+import { logCliConfiguration, logIdeConnection } from '../telemetry/loggers.js';
+import { IdeConnectionEvent, IdeConnectionType } from '../telemetry/types.js';
+
+// Re-export OAuth config type
+export type { MCPOAuthConfig };
+import { WorkspaceContext } from '../utils/workspaceContext.js';
+
+export enum ApprovalMode {
+  DEFAULT = 'default',
+  AUTO_EDIT = 'autoEdit',
+  YOLO = 'yolo',
+}
+
+export interface AccessibilitySettings {
+  disableLoadingPhrases?: boolean;
+}
+
+export interface BugCommandSettings {
+  urlTemplate: string;
+}
+
+export interface ChatCompressionSettings {
+  contextPercentageThreshold?: number;
+}
+
+export interface SummarizeToolOutputSettings {
+  tokenBudget?: number;
+}
+
+export interface TelemetrySettings {
+  enabled?: boolean;
+  target?: TelemetryTarget;
+  otlpEndpoint?: string;
+  otlpProtocol?: 'grpc' | 'http';
+  logPrompts?: boolean;
+  outfile?: string;
+}
+
+export interface GitCoAuthorSettings {
+  enabled?: boolean;
+  name?: string;
+  email?: string;
+}
+
+export interface GeminiCLIExtension {
+  name: string;
+  version: string;
+  isActive: boolean;
+  path: string;
+}
+export interface FileFilteringOptions {
+  respectGitIgnore: boolean;
+  respectGeminiIgnore: boolean;
+}
+// For memory files
+export const DEFAULT_MEMORY_FILE_FILTERING_OPTIONS: FileFilteringOptions = {
+  respectGitIgnore: false,
+  respectGeminiIgnore: true,
+};
+// For all other files
+export const DEFAULT_FILE_FILTERING_OPTIONS: FileFilteringOptions = {
+  respectGitIgnore: true,
+  respectGeminiIgnore: true,
+};
+export class MCPServerConfig {
+  constructor(
+    // For stdio transport
+    readonly command?: string,
+    readonly args?: string[],
+    readonly env?: Record<string, string>,
+    readonly cwd?: string,
+    // For sse transport
+    readonly url?: string,
+    // For streamable http transport
+    readonly httpUrl?: string,
+    readonly headers?: Record<string, string>,
+    // For websocket transport
+    readonly tcp?: string,
+    // Common
+    readonly timeout?: number,
+    readonly trust?: boolean,
+    // Metadata
+    readonly description?: string,
+    readonly includeTools?: string[],
+    readonly excludeTools?: string[],
+    readonly extensionName?: string,
+    // OAuth configuration
+    readonly oauth?: MCPOAuthConfig,
+    readonly authProviderType?: AuthProviderType,
+  ) {}
+}
+
+export enum AuthProviderType {
+  DYNAMIC_DISCOVERY = 'dynamic_discovery',
+  GOOGLE_CREDENTIALS = 'google_credentials',
+}
+
+export interface SandboxConfig {
+  command: 'docker' | 'podman' | 'sandbox-exec';
+  image: string;
+}
+
+export type FlashFallbackHandler = (
+  currentModel: string,
+  fallbackModel: string,
+  error?: unknown,
+) => Promise<boolean | string | null>;
+
+export interface ConfigParameters {
+  sessionId: string;
+  embeddingModel?: string;
+  sandbox?: SandboxConfig;
+  targetDir: string;
+  debugMode: boolean;
+  question?: string;
+  fullContext?: boolean;
+  coreTools?: string[];
+  excludeTools?: string[];
+  toolDiscoveryCommand?: string;
+  toolCallCommand?: string;
+  mcpServerCommand?: string;
+  mcpServers?: Record<string, MCPServerConfig>;
+  userMemory?: string;
+  geminiMdFileCount?: number;
+  approvalMode?: ApprovalMode;
+  showMemoryUsage?: boolean;
+  contextFileName?: string | string[];
+  accessibility?: AccessibilitySettings;
+  telemetry?: TelemetrySettings;
+  gitCoAuthor?: GitCoAuthorSettings;
+  usageStatisticsEnabled?: boolean;
+  fileFiltering?: {
+    respectGitIgnore?: boolean;
+    respectGeminiIgnore?: boolean;
+    enableRecursiveFileSearch?: boolean;
+  };
+  checkpointing?: boolean;
+  proxy?: string;
+  cwd: string;
+  fileDiscoveryService?: FileDiscoveryService;
+  includeDirectories?: string[];
+  bugCommand?: BugCommandSettings;
+  model: string;
+  extensionContextFilePaths?: string[];
+  maxSessionTurns?: number;
+  sessionTokenLimit?: number;
+  experimentalZedIntegration?: boolean;
+  listExtensions?: boolean;
+  extensions?: GeminiCLIExtension[];
+  blockedMcpServers?: Array<{ name: string; extensionName: string }>;
+  noBrowser?: boolean;
+  summarizeToolOutput?: Record<string, SummarizeToolOutputSettings>;
+  folderTrustFeature?: boolean;
+  folderTrust?: boolean;
+  ideMode?: boolean;
+  enableOpenAILogging?: boolean;
+  systemPromptMappings?: Array<{
+    baseUrls: string[];
+    modelNames: string[];
+    template: string;
+  }>;
+  authType?: AuthType;
+  contentGenerator?: {
+    timeout?: number;
+    maxRetries?: number;
+    samplingParams?: {
+      [key: string]: unknown;
+    };
+  };
+  cliVersion?: string;
+  loadMemoryFromIncludeDirectories?: boolean;
+  // Web search providers
+  tavilyApiKey?: string;
+  chatCompression?: ChatCompressionSettings;
+  interactive?: boolean;
+  trustedFolder?: boolean;
+  shouldUseNodePtyShell?: boolean;
+  skipNextSpeakerCheck?: boolean;
+}
+
+export class Config {
+  private toolRegistry!: ToolRegistry;
+  private promptRegistry!: PromptRegistry;
+  private sessionId: string;
+  private fileSystemService: FileSystemService;
+  private contentGeneratorConfig!: ContentGeneratorConfig;
+  private readonly embeddingModel: string;
+  private readonly sandbox: SandboxConfig | undefined;
+  private readonly targetDir: string;
+  private workspaceContext: WorkspaceContext;
+  private readonly debugMode: boolean;
+  private readonly question: string | undefined;
+  private readonly fullContext: boolean;
+  private readonly coreTools: string[] | undefined;
+  private readonly excludeTools: string[] | undefined;
+  private readonly toolDiscoveryCommand: string | undefined;
+  private readonly toolCallCommand: string | undefined;
+  private readonly mcpServerCommand: string | undefined;
+  private readonly mcpServers: Record<string, MCPServerConfig> | undefined;
+  private userMemory: string;
+  private geminiMdFileCount: number;
+  private approvalMode: ApprovalMode;
+  private readonly showMemoryUsage: boolean;
+  private readonly accessibility: AccessibilitySettings;
+  private readonly telemetrySettings: TelemetrySettings;
+  private readonly gitCoAuthor: GitCoAuthorSettings;
+  private readonly usageStatisticsEnabled: boolean;
+  private geminiClient!: GeminiClient;
+  private readonly fileFiltering: {
+    respectGitIgnore: boolean;
+    respectGeminiIgnore: boolean;
+    enableRecursiveFileSearch: boolean;
+  };
+  private fileDiscoveryService: FileDiscoveryService | null = null;
+  private gitService: GitService | undefined = undefined;
+  private readonly checkpointing: boolean;
+  private readonly proxy: string | undefined;
+  private readonly cwd: string;
+  private readonly bugCommand: BugCommandSettings | undefined;
+  private readonly model: string;
+  private readonly extensionContextFilePaths: string[];
+  private readonly noBrowser: boolean;
+  private readonly folderTrustFeature: boolean;
+  private readonly folderTrust: boolean;
+  private ideMode: boolean;
+  private ideClient: IdeClient;
+  private inFallbackMode = false;
+  private readonly systemPromptMappings?: Array<{
+    baseUrls?: string[];
+    modelNames?: string[];
+    template?: string;
+  }>;
+  private readonly maxSessionTurns: number;
+  private readonly sessionTokenLimit: number;
+  private readonly listExtensions: boolean;
+  private readonly _extensions: GeminiCLIExtension[];
+  private readonly _blockedMcpServers: Array<{
+    name: string;
+    extensionName: string;
+  }>;
+  flashFallbackHandler?: FlashFallbackHandler;
+  private quotaErrorOccurred: boolean = false;
+  private readonly summarizeToolOutput:
+    | Record<string, SummarizeToolOutputSettings>
+    | undefined;
+  private authType?: AuthType;
+  private readonly enableOpenAILogging: boolean;
+  private readonly contentGenerator?: {
+    timeout?: number;
+    maxRetries?: number;
+    samplingParams?: Record<string, unknown>;
+  };
+  private readonly cliVersion?: string;
+  private readonly experimentalZedIntegration: boolean = false;
+  private readonly loadMemoryFromIncludeDirectories: boolean = false;
+  private readonly tavilyApiKey?: string;
+  private readonly chatCompression: ChatCompressionSettings | undefined;
+  private readonly interactive: boolean;
+  private readonly trustedFolder: boolean | undefined;
+  private readonly shouldUseNodePtyShell: boolean;
+  private readonly skipNextSpeakerCheck: boolean;
+  private initialized: boolean = false;
+
+  constructor(params: ConfigParameters) {
+    this.sessionId = params.sessionId;
+    this.embeddingModel =
+      params.embeddingModel ?? DEFAULT_GEMINI_EMBEDDING_MODEL;
+    this.fileSystemService = new StandardFileSystemService();
+    this.sandbox = params.sandbox;
+    this.targetDir = path.resolve(params.targetDir);
+    this.workspaceContext = new WorkspaceContext(
+      this.targetDir,
+      params.includeDirectories ?? [],
+    );
+    this.debugMode = params.debugMode;
+    this.question = params.question;
+    this.fullContext = params.fullContext ?? false;
+    this.coreTools = params.coreTools;
+    this.excludeTools = params.excludeTools;
+    this.toolDiscoveryCommand = params.toolDiscoveryCommand;
+    this.toolCallCommand = params.toolCallCommand;
+    this.mcpServerCommand = params.mcpServerCommand;
+    this.mcpServers = params.mcpServers;
+    this.userMemory = params.userMemory ?? '';
+    this.geminiMdFileCount = params.geminiMdFileCount ?? 0;
+    this.approvalMode = params.approvalMode ?? ApprovalMode.DEFAULT;
+    this.showMemoryUsage = params.showMemoryUsage ?? false;
+    this.accessibility = params.accessibility ?? {};
+    this.telemetrySettings = {
+      enabled: params.telemetry?.enabled ?? false,
+      target: params.telemetry?.target ?? DEFAULT_TELEMETRY_TARGET,
+      otlpEndpoint: params.telemetry?.otlpEndpoint ?? DEFAULT_OTLP_ENDPOINT,
+      otlpProtocol: params.telemetry?.otlpProtocol,
+      logPrompts: params.telemetry?.logPrompts ?? true,
+      outfile: params.telemetry?.outfile,
+    };
+    this.gitCoAuthor = {
+      enabled: params.gitCoAuthor?.enabled ?? true,
+      name: params.gitCoAuthor?.name ?? 'Qwen-Coder',
+      email: params.gitCoAuthor?.email ?? 'qwen-coder@alibabacloud.com',
+    };
+    this.usageStatisticsEnabled = params.usageStatisticsEnabled ?? true;
+
+    this.fileFiltering = {
+      respectGitIgnore: params.fileFiltering?.respectGitIgnore ?? true,
+      respectGeminiIgnore: params.fileFiltering?.respectGeminiIgnore ?? true,
+      enableRecursiveFileSearch:
+        params.fileFiltering?.enableRecursiveFileSearch ?? true,
+    };
+    this.checkpointing = params.checkpointing ?? false;
+    this.proxy = params.proxy;
+    this.cwd = params.cwd ?? process.cwd();
+    this.fileDiscoveryService = params.fileDiscoveryService ?? null;
+    this.bugCommand = params.bugCommand;
+    this.model = params.model;
+    this.extensionContextFilePaths = params.extensionContextFilePaths ?? [];
+    this.maxSessionTurns = params.maxSessionTurns ?? -1;
+    this.sessionTokenLimit = params.sessionTokenLimit ?? -1;
+    this.experimentalZedIntegration =
+      params.experimentalZedIntegration ?? false;
+    this.listExtensions = params.listExtensions ?? false;
+    this._extensions = params.extensions ?? [];
+    this._blockedMcpServers = params.blockedMcpServers ?? [];
+    this.noBrowser = params.noBrowser ?? false;
+    this.summarizeToolOutput = params.summarizeToolOutput;
+    this.folderTrustFeature = params.folderTrustFeature ?? false;
+    this.folderTrust = params.folderTrust ?? false;
+    this.ideMode = params.ideMode ?? false;
+    this.ideClient = IdeClient.getInstance();
+    this.systemPromptMappings = params.systemPromptMappings;
+    this.authType = params.authType;
+    this.enableOpenAILogging = params.enableOpenAILogging ?? false;
+    this.contentGenerator = params.contentGenerator;
+    this.cliVersion = params.cliVersion;
+
+    this.loadMemoryFromIncludeDirectories =
+      params.loadMemoryFromIncludeDirectories ?? false;
+    this.chatCompression = params.chatCompression;
+    this.interactive = params.interactive ?? false;
+    this.trustedFolder = params.trustedFolder;
+    this.shouldUseNodePtyShell = params.shouldUseNodePtyShell ?? false;
+    this.skipNextSpeakerCheck = params.skipNextSpeakerCheck ?? false;
+
+    // Web search
+    this.tavilyApiKey = params.tavilyApiKey;
+
+    if (params.contextFileName) {
+      setGeminiMdFilename(params.contextFileName);
+    }
+
+    if (this.telemetrySettings.enabled) {
+      initializeTelemetry(this);
+    }
+
+    logCliConfiguration(this, new StartSessionEvent(this));
+  }
+
+  /**
+   * Must only be called once, throws if called again.
+   */
+  async initialize(): Promise<void> {
+    if (this.initialized) {
+      throw Error('Config was already initialized');
+    }
+    this.initialized = true;
+    // Initialize centralized FileDiscoveryService
+    this.getFileService();
+    if (this.getCheckpointingEnabled()) {
+      await this.getGitService();
+    }
+    this.promptRegistry = new PromptRegistry();
+    this.toolRegistry = await this.createToolRegistry();
+  }
+
+  async refreshAuth(authMethod: AuthType) {
+    // Save the current conversation history before creating a new client
+    let existingHistory: Content[] = [];
+    if (this.geminiClient && this.geminiClient.isInitialized()) {
+      existingHistory = this.geminiClient.getHistory();
+    }
+
+    // Create new content generator config
+    const newContentGeneratorConfig = createContentGeneratorConfig(
+      this,
+      authMethod,
+    );
+
+    // Create and initialize new client in local variable first
+    const newGeminiClient = new GeminiClient(this);
+    await newGeminiClient.initialize(newContentGeneratorConfig);
+
+    // Vertex and Genai have incompatible encryption and sending history with
+    // throughtSignature from Genai to Vertex will fail, we need to strip them
+    const fromGenaiToVertex =
+      this.contentGeneratorConfig?.authType === AuthType.USE_GEMINI &&
+      authMethod === AuthType.LOGIN_WITH_GOOGLE;
+
+    // Only assign to instance properties after successful initialization
+    this.contentGeneratorConfig = newContentGeneratorConfig;
+    this.geminiClient = newGeminiClient;
+
+    // Restore the conversation history to the new client
+    if (existingHistory.length > 0) {
+      this.geminiClient.setHistory(existingHistory, {
+        stripThoughts: fromGenaiToVertex,
+      });
+    }
+
+    // Reset the session flag since we're explicitly changing auth and using default model
+    this.inFallbackMode = false;
+
+    this.authType = authMethod;
+  }
+
+  getSessionId(): string {
+    return this.sessionId;
+  }
+
+  setSessionId(sessionId: string): void {
+    this.sessionId = sessionId;
+  }
+
+  shouldLoadMemoryFromIncludeDirectories(): boolean {
+    return this.loadMemoryFromIncludeDirectories;
+  }
+
+  getContentGeneratorConfig(): ContentGeneratorConfig {
+    return this.contentGeneratorConfig;
+  }
+
+  getModel(): string {
+    return this.contentGeneratorConfig?.model || this.model;
+  }
+
+  setModel(newModel: string): void {
+    if (this.contentGeneratorConfig) {
+      this.contentGeneratorConfig.model = newModel;
+    }
+  }
+
+  isInFallbackMode(): boolean {
+    return this.inFallbackMode;
+  }
+
+  setFallbackMode(active: boolean): void {
+    this.inFallbackMode = active;
+  }
+
+  setFlashFallbackHandler(handler: FlashFallbackHandler): void {
+    this.flashFallbackHandler = handler;
+  }
+
+  getMaxSessionTurns(): number {
+    return this.maxSessionTurns;
+  }
+
+  getSessionTokenLimit(): number {
+    return this.sessionTokenLimit;
+  }
+
+  setQuotaErrorOccurred(value: boolean): void {
+    this.quotaErrorOccurred = value;
+  }
+
+  getQuotaErrorOccurred(): boolean {
+    return this.quotaErrorOccurred;
+  }
+
+  getEmbeddingModel(): string {
+    return this.embeddingModel;
+  }
+
+  getSandbox(): SandboxConfig | undefined {
+    return this.sandbox;
+  }
+
+  isRestrictiveSandbox(): boolean {
+    const sandboxConfig = this.getSandbox();
+    const seatbeltProfile = process.env['SEATBELT_PROFILE'];
+    return (
+      !!sandboxConfig &&
+      sandboxConfig.command === 'sandbox-exec' &&
+      !!seatbeltProfile &&
+      seatbeltProfile.startsWith('restrictive-')
+    );
+  }
+
+  getTargetDir(): string {
+    return this.targetDir;
+  }
+
+  getProjectRoot(): string {
+    return this.targetDir;
+  }
+
+  getWorkspaceContext(): WorkspaceContext {
+    return this.workspaceContext;
+  }
+
+  getToolRegistry(): ToolRegistry {
+    return this.toolRegistry;
+  }
+
+  getPromptRegistry(): PromptRegistry {
+    return this.promptRegistry;
+  }
+
+  getDebugMode(): boolean {
+    return this.debugMode;
+  }
+
+  getQuestion(): string | undefined {
+    return this.question;
+  }
+
+  getFullContext(): boolean {
+    return this.fullContext;
+  }
+
+  getCoreTools(): string[] | undefined {
+    return this.coreTools;
+  }
+
+  getExcludeTools(): string[] | undefined {
+    return this.excludeTools;
+  }
+
+  getToolDiscoveryCommand(): string | undefined {
+    return this.toolDiscoveryCommand;
+  }
+
+  getToolCallCommand(): string | undefined {
+    return this.toolCallCommand;
+  }
+
+  getMcpServerCommand(): string | undefined {
+    return this.mcpServerCommand;
+  }
+
+  getMcpServers(): Record<string, MCPServerConfig> | undefined {
+    return this.mcpServers;
+  }
+
+  getUserMemory(): string {
+    return this.userMemory;
+  }
+
+  setUserMemory(newUserMemory: string): void {
+    this.userMemory = newUserMemory;
+  }
+
+  getGeminiMdFileCount(): number {
+    return this.geminiMdFileCount;
+  }
+
+  setGeminiMdFileCount(count: number): void {
+    this.geminiMdFileCount = count;
+  }
+
+  getApprovalMode(): ApprovalMode {
+    return this.approvalMode;
+  }
+
+  setApprovalMode(mode: ApprovalMode): void {
+    this.approvalMode = mode;
+  }
+
+  getShowMemoryUsage(): boolean {
+    return this.showMemoryUsage;
+  }
+
+  getAccessibility(): AccessibilitySettings {
+    return this.accessibility;
+  }
+
+  getTelemetryEnabled(): boolean {
+    return this.telemetrySettings.enabled ?? false;
+  }
+
+  getTelemetryLogPromptsEnabled(): boolean {
+    return this.telemetrySettings.logPrompts ?? true;
+  }
+
+  getTelemetryOtlpEndpoint(): string {
+    return this.telemetrySettings.otlpEndpoint ?? DEFAULT_OTLP_ENDPOINT;
+  }
+
+  getTelemetryOtlpProtocol(): 'grpc' | 'http' {
+    return this.telemetrySettings.otlpProtocol ?? 'grpc';
+  }
+
+  getTelemetryTarget(): TelemetryTarget {
+    return this.telemetrySettings.target ?? DEFAULT_TELEMETRY_TARGET;
+  }
+
+  getTelemetryOutfile(): string | undefined {
+    return this.telemetrySettings.outfile;
+  }
+
+  getGitCoAuthor(): GitCoAuthorSettings {
+    return this.gitCoAuthor;
+  }
+
+  getGeminiClient(): GeminiClient {
+    return this.geminiClient;
+  }
+
+  getGeminiDir(): string {
+    return path.join(this.targetDir, GEMINI_DIR);
+  }
+
+  getProjectTempDir(): string {
+    return getProjectTempDir(this.getProjectRoot());
+  }
+
+  getEnableRecursiveFileSearch(): boolean {
+    return this.fileFiltering.enableRecursiveFileSearch;
+  }
+
+  getFileFilteringRespectGitIgnore(): boolean {
+    return this.fileFiltering.respectGitIgnore;
+  }
+  getFileFilteringRespectGeminiIgnore(): boolean {
+    return this.fileFiltering.respectGeminiIgnore;
+  }
+
+  getFileFilteringOptions(): FileFilteringOptions {
+    return {
+      respectGitIgnore: this.fileFiltering.respectGitIgnore,
+      respectGeminiIgnore: this.fileFiltering.respectGeminiIgnore,
+    };
+  }
+
+  getCheckpointingEnabled(): boolean {
+    return this.checkpointing;
+  }
+
+  getProxy(): string | undefined {
+    return this.proxy;
+  }
+
+  getWorkingDir(): string {
+    return this.cwd;
+  }
+
+  getBugCommand(): BugCommandSettings | undefined {
+    return this.bugCommand;
+  }
+
+  getFileService(): FileDiscoveryService {
+    if (!this.fileDiscoveryService) {
+      this.fileDiscoveryService = new FileDiscoveryService(this.targetDir);
+    }
+    return this.fileDiscoveryService;
+  }
+
+  getUsageStatisticsEnabled(): boolean {
+    return this.usageStatisticsEnabled;
+  }
+
+  getExtensionContextFilePaths(): string[] {
+    return this.extensionContextFilePaths;
+  }
+
+  getExperimentalZedIntegration(): boolean {
+    return this.experimentalZedIntegration;
+  }
+
+  getListExtensions(): boolean {
+    return this.listExtensions;
+  }
+
+  getExtensions(): GeminiCLIExtension[] {
+    return this._extensions;
+  }
+
+  getBlockedMcpServers(): Array<{ name: string; extensionName: string }> {
+    return this._blockedMcpServers;
+  }
+
+  getNoBrowser(): boolean {
+    return this.noBrowser;
+  }
+
+  isBrowserLaunchSuppressed(): boolean {
+    return this.getNoBrowser() || !shouldAttemptBrowserLaunch();
+  }
+
+  getSummarizeToolOutputConfig():
+    | Record<string, SummarizeToolOutputSettings>
+    | undefined {
+    return this.summarizeToolOutput;
+  }
+
+  // Web search provider configuration
+  getTavilyApiKey(): string | undefined {
+    return this.tavilyApiKey;
+  }
+
+  getIdeClient(): IdeClient {
+    return this.ideClient;
+  }
+
+  getIdeMode(): boolean {
+    return this.ideMode;
+  }
+
+  getFolderTrustFeature(): boolean {
+    return this.folderTrustFeature;
+  }
+
+  getFolderTrust(): boolean {
+    return this.folderTrust;
+  }
+
+  isTrustedFolder(): boolean | undefined {
+    return this.trustedFolder;
+  }
+
+  setIdeMode(value: boolean): void {
+    this.ideMode = value;
+  }
+
+  async setIdeModeAndSyncConnection(value: boolean): Promise<void> {
+    this.ideMode = value;
+    if (value) {
+      await this.ideClient.connect();
+      logIdeConnection(this, new IdeConnectionEvent(IdeConnectionType.SESSION));
+    } else {
+      await this.ideClient.disconnect();
+    }
+  }
+
+  getAuthType(): AuthType | undefined {
+    return this.authType;
+  }
+
+  getEnableOpenAILogging(): boolean {
+    return this.enableOpenAILogging;
+  }
+
+  getContentGeneratorTimeout(): number | undefined {
+    return this.contentGenerator?.timeout;
+  }
+
+  getContentGeneratorMaxRetries(): number | undefined {
+    return this.contentGenerator?.maxRetries;
+  }
+
+  getContentGeneratorSamplingParams(): ContentGeneratorConfig['samplingParams'] {
+    return this.contentGenerator?.samplingParams as
+      | ContentGeneratorConfig['samplingParams']
+      | undefined;
+  }
+
+  getCliVersion(): string | undefined {
+    return this.cliVersion;
+  }
+
+  getSystemPromptMappings():
+    | Array<{
+        baseUrls?: string[];
+        modelNames?: string[];
+        template?: string;
+      }>
+    | undefined {
+    return this.systemPromptMappings;
+  }
+
+  /**
+   * Get the current FileSystemService
+   */
+  getFileSystemService(): FileSystemService {
+    return this.fileSystemService;
+  }
+
+  /**
+   * Set a custom FileSystemService
+   */
+  setFileSystemService(fileSystemService: FileSystemService): void {
+    this.fileSystemService = fileSystemService;
+  }
+
+  getChatCompression(): ChatCompressionSettings | undefined {
+    return this.chatCompression;
+  }
+
+  isInteractive(): boolean {
+    return this.interactive;
+  }
+
+  getShouldUseNodePtyShell(): boolean {
+    return this.shouldUseNodePtyShell;
+  }
+
+  getSkipNextSpeakerCheck(): boolean {
+    return this.skipNextSpeakerCheck;
+  }
+
+  async getGitService(): Promise<GitService> {
+    if (!this.gitService) {
+      this.gitService = new GitService(this.targetDir);
+      await this.gitService.initialize();
+    }
+    return this.gitService;
+  }
+
+  async createToolRegistry(): Promise<ToolRegistry> {
+    const registry = new ToolRegistry(this);
+
+    // helper to create & register core tools that are enabled
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const registerCoreTool = (ToolClass: any, ...args: unknown[]) => {
+      const className = ToolClass.name;
+      const toolName = ToolClass.Name || className;
+      const coreTools = this.getCoreTools();
+      const excludeTools = this.getExcludeTools();
+
+      let isEnabled = false;
+      if (coreTools === undefined) {
+        isEnabled = true;
+      } else {
+        isEnabled = coreTools.some(
+          (tool) =>
+            tool === className ||
+            tool === toolName ||
+            tool.startsWith(`${className}(`) ||
+            tool.startsWith(`${toolName}(`),
+        );
+      }
+
+      if (
+        excludeTools?.includes(className) ||
+        excludeTools?.includes(toolName)
+      ) {
+        isEnabled = false;
+      }
+
+      if (isEnabled) {
+        registry.registerTool(new ToolClass(...args));
+      }
+    };
+
+    registerCoreTool(LSTool, this);
+    registerCoreTool(ReadFileTool, this);
+    registerCoreTool(GrepTool, this);
+    registerCoreTool(GlobTool, this);
+    registerCoreTool(EditTool, this);
+    registerCoreTool(WriteFileTool, this);
+    registerCoreTool(WebFetchTool, this);
+    registerCoreTool(ReadManyFilesTool, this);
+    registerCoreTool(ShellTool, this);
+    registerCoreTool(MemoryTool);
+    registerCoreTool(TodoWriteTool, this);
+    // Conditionally register web search tool only if Tavily API key is set
+    if (this.getTavilyApiKey()) {
+      registerCoreTool(WebSearchTool, this);
+    }
+
+    await registry.discoverAllTools();
+    return registry;
+  }
+}
+// Export model constants for use in CLI
+export { DEFAULT_GEMINI_FLASH_MODEL };

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

@@ -0,0 +1,102 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { Config } from './config.js';
+import { DEFAULT_GEMINI_MODEL, DEFAULT_GEMINI_FLASH_MODEL } from './models.js';
+import fs from 'node:fs';
+
+vi.mock('node:fs');
+
+describe('Flash Model Fallback Configuration', () => {
+  let config: Config;
+
+  beforeEach(() => {
+    vi.mocked(fs.existsSync).mockReturnValue(true);
+    vi.mocked(fs.statSync).mockReturnValue({
+      isDirectory: () => true,
+    } as fs.Stats);
+    config = new Config({
+      sessionId: 'test-session',
+      targetDir: '/test',
+      debugMode: false,
+      cwd: '/test',
+      model: DEFAULT_GEMINI_MODEL,
+    });
+
+    // Initialize contentGeneratorConfig for testing
+    (
+      config as unknown as { contentGeneratorConfig: unknown }
+    ).contentGeneratorConfig = {
+      model: DEFAULT_GEMINI_MODEL,
+      authType: 'oauth-personal',
+    };
+  });
+
+  // These tests do not actually test fallback. isInFallbackMode() only returns true,
+  // when setFallbackMode is marked as true. This is to decouple setting a model
+  // with the fallback mechanism. This will be necessary we introduce more
+  // intelligent model routing.
+  describe('setModel', () => {
+    it('should only mark as switched if contentGeneratorConfig exists', () => {
+      // Create config without initializing contentGeneratorConfig
+      const newConfig = new Config({
+        sessionId: 'test-session-2',
+        targetDir: '/test',
+        debugMode: false,
+        cwd: '/test',
+        model: DEFAULT_GEMINI_MODEL,
+      });
+
+      // Should not crash when contentGeneratorConfig is undefined
+      newConfig.setModel(DEFAULT_GEMINI_FLASH_MODEL);
+      expect(newConfig.isInFallbackMode()).toBe(false);
+    });
+  });
+
+  describe('getModel', () => {
+    it('should return contentGeneratorConfig model if available', () => {
+      // Simulate initialized content generator config
+      config.setModel(DEFAULT_GEMINI_FLASH_MODEL);
+      expect(config.getModel()).toBe(DEFAULT_GEMINI_FLASH_MODEL);
+    });
+
+    it('should fall back to initial model if contentGeneratorConfig is not available', () => {
+      // Test with fresh config where contentGeneratorConfig might not be set
+      const newConfig = new Config({
+        sessionId: 'test-session-2',
+        targetDir: '/test',
+        debugMode: false,
+        cwd: '/test',
+        model: 'custom-model',
+      });
+
+      expect(newConfig.getModel()).toBe('custom-model');
+    });
+  });
+
+  describe('isInFallbackMode', () => {
+    it('should start as false for new session', () => {
+      expect(config.isInFallbackMode()).toBe(false);
+    });
+
+    it('should remain false if no model switch occurs', () => {
+      // Perform other operations that don't involve model switching
+      expect(config.isInFallbackMode()).toBe(false);
+    });
+
+    it('should persist switched state throughout session', () => {
+      config.setModel(DEFAULT_GEMINI_FLASH_MODEL);
+      // Setting state for fallback mode as is expected of clients
+      config.setFallbackMode(true);
+      expect(config.isInFallbackMode()).toBe(true);
+
+      // Should remain true even after getting model
+      config.getModel();
+      expect(config.isInFallbackMode()).toBe(true);
+    });
+  });
+});

projects/ui/qwen-code/packages/core/src/config/models.ts

@@ -0,0 +1,15 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+export const DEFAULT_QWEN_MODEL = 'qwen3-coder-plus';
+// We do not have a fallback model for now, but note it here anyway.
+export const DEFAULT_QWEN_FLASH_MODEL = 'qwen3-coder-flash';
+
+export const DEFAULT_GEMINI_MODEL = 'qwen3-coder-plus';
+export const DEFAULT_GEMINI_FLASH_MODEL = 'gemini-2.5-flash';
+export const DEFAULT_GEMINI_FLASH_LITE_MODEL = 'gemini-2.5-flash-lite';
+
+export const DEFAULT_GEMINI_EMBEDDING_MODEL = 'gemini-embedding-001';

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

@@ -0,0 +1,2176 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+
+import {
+  Chat,
+  Content,
+  EmbedContentResponse,
+  GenerateContentResponse,
+  GoogleGenAI,
+} from '@google/genai';
+import { findIndexAfterFraction, GeminiClient } from './client.js';
+import { AuthType, ContentGenerator } from './contentGenerator.js';
+import { GeminiChat } from './geminiChat.js';
+import { Config } from '../config/config.js';
+import { GeminiEventType, Turn } from './turn.js';
+import { getCoreSystemPrompt } from './prompts.js';
+import { DEFAULT_GEMINI_FLASH_MODEL } from '../config/models.js';
+import { FileDiscoveryService } from '../services/fileDiscoveryService.js';
+import { setSimulate429 } from '../utils/testUtils.js';
+import { tokenLimit } from './tokenLimits.js';
+import { ideContext } from '../ide/ideContext.js';
+import { QwenLogger } from '../telemetry/qwen-logger/qwen-logger.js';
+
+// --- Mocks ---
+const mockChatCreateFn = vi.fn();
+const mockGenerateContentFn = vi.fn();
+const mockEmbedContentFn = vi.fn();
+const mockTurnRunFn = vi.fn();
+
+vi.mock('@google/genai');
+vi.mock('./turn', () => {
+  // Define a mock class that has the same shape as the real Turn
+  class MockTurn {
+    pendingToolCalls = [];
+    // The run method is a property that holds our mock function
+    run = mockTurnRunFn;
+
+    constructor() {
+      // The constructor can be empty or do some mock setup
+    }
+  }
+  // Export the mock class as 'Turn'
+  return {
+    Turn: MockTurn,
+    GeminiEventType: {
+      MaxSessionTurns: 'MaxSessionTurns',
+      ChatCompressed: 'ChatCompressed',
+      Error: 'error',
+      Content: 'content',
+    },
+  };
+});
+
+vi.mock('../config/config.js');
+vi.mock('./prompts');
+vi.mock('../utils/getFolderStructure', () => ({
+  getFolderStructure: vi.fn().mockResolvedValue('Mock Folder Structure'),
+}));
+vi.mock('../utils/errorReporting', () => ({ reportError: vi.fn() }));
+vi.mock('../utils/nextSpeakerChecker', () => ({
+  checkNextSpeaker: vi.fn().mockResolvedValue(null),
+}));
+vi.mock('../utils/generateContentResponseUtilities', () => ({
+  getResponseText: (result: GenerateContentResponse) =>
+    result.candidates?.[0]?.content?.parts?.map((part) => part.text).join('') ||
+    undefined,
+  getFunctionCalls: (result: GenerateContentResponse) => {
+    // Extract function calls from the response
+    const parts = result.candidates?.[0]?.content?.parts;
+    if (!parts) {
+      return undefined;
+    }
+    const functionCallParts = parts
+      .filter((part) => !!part.functionCall)
+      .map((part) => part.functionCall);
+    return functionCallParts.length > 0 ? functionCallParts : undefined;
+  },
+}));
+vi.mock('../telemetry/index.js', () => ({
+  logApiRequest: vi.fn(),
+  logApiResponse: vi.fn(),
+  logApiError: vi.fn(),
+}));
+vi.mock('../ide/ideContext.js');
+
+describe('findIndexAfterFraction', () => {
+  const history: Content[] = [
+    { role: 'user', parts: [{ text: 'This is the first message.' }] }, // JSON length: 66
+    { role: 'model', parts: [{ text: 'This is the second message.' }] }, // JSON length: 68
+    { role: 'user', parts: [{ text: 'This is the third message.' }] }, // JSON length: 66
+    { role: 'model', parts: [{ text: 'This is the fourth message.' }] }, // JSON length: 68
+    { role: 'user', parts: [{ text: 'This is the fifth message.' }] }, // JSON length: 65
+  ];
+  // Total length: 333
+
+  it('should throw an error for non-positive numbers', () => {
+    expect(() => findIndexAfterFraction(history, 0)).toThrow(
+      'Fraction must be between 0 and 1',
+    );
+  });
+
+  it('should throw an error for a fraction greater than or equal to 1', () => {
+    expect(() => findIndexAfterFraction(history, 1)).toThrow(
+      'Fraction must be between 0 and 1',
+    );
+  });
+
+  it('should handle a fraction in the middle', () => {
+    // 333 * 0.5 = 166.5
+    // 0: 66
+    // 1: 66 + 68 = 134
+    // 2: 134 + 66 = 200
+    // 200 >= 166.5, so index is 2
+    expect(findIndexAfterFraction(history, 0.5)).toBe(2);
+  });
+
+  it('should handle a fraction that results in the last index', () => {
+    // 333 * 0.9 = 299.7
+    // ...
+    // 3: 200 + 68 = 268
+    // 4: 268 + 65 = 333
+    // 333 >= 299.7, so index is 4
+    expect(findIndexAfterFraction(history, 0.9)).toBe(4);
+  });
+
+  it('should handle an empty history', () => {
+    expect(findIndexAfterFraction([], 0.5)).toBe(0);
+  });
+
+  it('should handle a history with only one item', () => {
+    expect(findIndexAfterFraction(history.slice(0, 1), 0.5)).toBe(0);
+  });
+
+  it('should handle history with weird parts', () => {
+    const historyWithEmptyParts: Content[] = [
+      { role: 'user', parts: [{ text: 'Message 1' }] },
+      { role: 'model', parts: [{ fileData: { fileUri: 'derp' } }] },
+      { role: 'user', parts: [{ text: 'Message 2' }] },
+    ];
+    expect(findIndexAfterFraction(historyWithEmptyParts, 0.5)).toBe(1);
+  });
+});
+
+describe('Gemini Client (client.ts)', () => {
+  let client: GeminiClient;
+  beforeEach(async () => {
+    vi.resetAllMocks();
+
+    // Disable 429 simulation for tests
+    setSimulate429(false);
+
+    // Set up the mock for GoogleGenAI constructor and its methods
+    const MockedGoogleGenAI = vi.mocked(GoogleGenAI);
+    MockedGoogleGenAI.mockImplementation(() => {
+      const mock = {
+        chats: { create: mockChatCreateFn },
+        models: {
+          generateContent: mockGenerateContentFn,
+          embedContent: mockEmbedContentFn,
+        },
+      };
+      return mock as unknown as GoogleGenAI;
+    });
+
+    mockChatCreateFn.mockResolvedValue({} as Chat);
+    mockGenerateContentFn.mockResolvedValue({
+      candidates: [
+        {
+          content: {
+            parts: [
+              {
+                functionCall: {
+                  name: 'respond_in_schema',
+                  args: { key: 'value' },
+                },
+              },
+            ],
+          },
+        },
+      ],
+    } as unknown as GenerateContentResponse);
+
+    // Because the GeminiClient constructor kicks off an async process (startChat)
+    // that depends on a fully-formed Config object, we need to mock the
+    // entire implementation of Config for these tests.
+    const mockToolRegistry = {
+      getFunctionDeclarations: vi.fn().mockReturnValue([]),
+      getTool: vi.fn().mockReturnValue(null),
+    };
+    const fileService = new FileDiscoveryService('/test/dir');
+    const contentGeneratorConfig = {
+      model: 'test-model',
+      apiKey: 'test-key',
+      vertexai: false,
+      authType: AuthType.USE_GEMINI,
+    };
+    const mockConfigObject = {
+      getContentGeneratorConfig: vi
+        .fn()
+        .mockReturnValue(contentGeneratorConfig),
+      getToolRegistry: vi.fn().mockReturnValue(mockToolRegistry),
+      getModel: vi.fn().mockReturnValue('test-model'),
+      getEmbeddingModel: vi.fn().mockReturnValue('test-embedding-model'),
+      getApiKey: vi.fn().mockReturnValue('test-key'),
+      getVertexAI: vi.fn().mockReturnValue(false),
+      getUserAgent: vi.fn().mockReturnValue('test-agent'),
+      getUserMemory: vi.fn().mockReturnValue(''),
+      getFullContext: vi.fn().mockReturnValue(false),
+      getSessionId: vi.fn().mockReturnValue('test-session-id'),
+      getProxy: vi.fn().mockReturnValue(undefined),
+      getWorkingDir: vi.fn().mockReturnValue('/test/dir'),
+      getFileService: vi.fn().mockReturnValue(fileService),
+      getMaxSessionTurns: vi.fn().mockReturnValue(0),
+      getSessionTokenLimit: vi.fn().mockReturnValue(32000),
+      getQuotaErrorOccurred: vi.fn().mockReturnValue(false),
+      setQuotaErrorOccurred: vi.fn(),
+      getNoBrowser: vi.fn().mockReturnValue(false),
+      getSystemPromptMappings: vi.fn().mockReturnValue(undefined),
+      getUsageStatisticsEnabled: vi.fn().mockReturnValue(true),
+      getIdeModeFeature: vi.fn().mockReturnValue(false),
+      getIdeMode: vi.fn().mockReturnValue(true),
+      getDebugMode: vi.fn().mockReturnValue(false),
+      getWorkspaceContext: vi.fn().mockReturnValue({
+        getDirectories: vi.fn().mockReturnValue(['/test/dir']),
+      }),
+      getGeminiClient: vi.fn(),
+      setFallbackMode: vi.fn(),
+      getCliVersion: vi.fn().mockReturnValue('1.0.0'),
+      getChatCompression: vi.fn().mockReturnValue(undefined),
+      getSkipNextSpeakerCheck: vi.fn().mockReturnValue(false),
+    };
+    const MockedConfig = vi.mocked(Config, true);
+    MockedConfig.mockImplementation(
+      () => mockConfigObject as unknown as Config,
+    );
+
+    // We can instantiate the client here since Config is mocked
+    // and the constructor will use the mocked GoogleGenAI
+    client = new GeminiClient(
+      new Config({ sessionId: 'test-session-id' } as never),
+    );
+    mockConfigObject.getGeminiClient.mockReturnValue(client);
+
+    await client.initialize(contentGeneratorConfig);
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  // NOTE: The following tests for startChat were removed due to persistent issues with
+  // the @google/genai mock. Specifically, the mockChatCreateFn (representing instance.chats.create)
+  // was not being detected as called by the GeminiClient instance.
+  // This likely points to a subtle issue in how the GoogleGenerativeAI class constructor
+  // and its instance methods are mocked and then used by the class under test.
+  // For future debugging, ensure that the `this.client` in `GeminiClient` (which is an
+  // instance of the mocked GoogleGenerativeAI) correctly has its `chats.create` method
+  // pointing to `mockChatCreateFn`.
+  // it('startChat should call getCoreSystemPrompt with userMemory and pass to chats.create', async () => { ... });
+  // it('startChat should call getCoreSystemPrompt with empty string if userMemory is empty', async () => { ... });
+
+  // NOTE: The following tests for generateJson were removed due to persistent issues with
+  // the @google/genai mock, similar to the startChat tests. The mockGenerateContentFn
+  // (representing instance.models.generateContent) was not being detected as called, or the mock
+  // was not preventing an actual API call (leading to API key errors).
+  // For future debugging, ensure `this.client.models.generateContent` in `GeminiClient` correctly
+  // uses the `mockGenerateContentFn`.
+  // it('generateJson should call getCoreSystemPrompt with userMemory and pass to generateContent', async () => { ... });
+  // it('generateJson should call getCoreSystemPrompt with empty string if userMemory is empty', async () => { ... });
+
+  describe('generateEmbedding', () => {
+    const texts = ['hello world', 'goodbye world'];
+    const testEmbeddingModel = 'test-embedding-model';
+
+    it('should call embedContent with correct parameters and return embeddings', async () => {
+      const mockEmbeddings = [
+        [0.1, 0.2, 0.3],
+        [0.4, 0.5, 0.6],
+      ];
+      const mockResponse: EmbedContentResponse = {
+        embeddings: [
+          { values: mockEmbeddings[0] },
+          { values: mockEmbeddings[1] },
+        ],
+      };
+      mockEmbedContentFn.mockResolvedValue(mockResponse);
+
+      const result = await client.generateEmbedding(texts);
+
+      expect(mockEmbedContentFn).toHaveBeenCalledTimes(1);
+      expect(mockEmbedContentFn).toHaveBeenCalledWith({
+        model: testEmbeddingModel,
+        contents: texts,
+      });
+      expect(result).toEqual(mockEmbeddings);
+    });
+
+    it('should return an empty array if an empty array is passed', async () => {
+      const result = await client.generateEmbedding([]);
+      expect(result).toEqual([]);
+      expect(mockEmbedContentFn).not.toHaveBeenCalled();
+    });
+
+    it('should throw an error if API response has no embeddings array', async () => {
+      mockEmbedContentFn.mockResolvedValue({} as EmbedContentResponse); // No `embeddings` key
+
+      await expect(client.generateEmbedding(texts)).rejects.toThrow(
+        'No embeddings found in API response.',
+      );
+    });
+
+    it('should throw an error if API response has an empty embeddings array', async () => {
+      const mockResponse: EmbedContentResponse = {
+        embeddings: [],
+      };
+      mockEmbedContentFn.mockResolvedValue(mockResponse);
+      await expect(client.generateEmbedding(texts)).rejects.toThrow(
+        'No embeddings found in API response.',
+      );
+    });
+
+    it('should throw an error if API returns a mismatched number of embeddings', async () => {
+      const mockResponse: EmbedContentResponse = {
+        embeddings: [{ values: [1, 2, 3] }], // Only one for two texts
+      };
+      mockEmbedContentFn.mockResolvedValue(mockResponse);
+
+      await expect(client.generateEmbedding(texts)).rejects.toThrow(
+        'API returned a mismatched number of embeddings. Expected 2, got 1.',
+      );
+    });
+
+    it('should throw an error if any embedding has nullish values', async () => {
+      const mockResponse: EmbedContentResponse = {
+        embeddings: [{ values: [1, 2, 3] }, { values: undefined }], // Second one is bad
+      };
+      mockEmbedContentFn.mockResolvedValue(mockResponse);
+
+      await expect(client.generateEmbedding(texts)).rejects.toThrow(
+        'API returned an empty embedding for input text at index 1: "goodbye world"',
+      );
+    });
+
+    it('should throw an error if any embedding has an empty values array', async () => {
+      const mockResponse: EmbedContentResponse = {
+        embeddings: [{ values: [] }, { values: [1, 2, 3] }], // First one is bad
+      };
+      mockEmbedContentFn.mockResolvedValue(mockResponse);
+
+      await expect(client.generateEmbedding(texts)).rejects.toThrow(
+        'API returned an empty embedding for input text at index 0: "hello world"',
+      );
+    });
+
+    it('should propagate errors from the API call', async () => {
+      const apiError = new Error('API Failure');
+      mockEmbedContentFn.mockRejectedValue(apiError);
+
+      await expect(client.generateEmbedding(texts)).rejects.toThrow(
+        'API Failure',
+      );
+    });
+  });
+
+  describe('generateContent', () => {
+    it('should call generateContent with the correct parameters', async () => {
+      const contents = [{ role: 'user', parts: [{ text: 'hello' }] }];
+      const generationConfig = { temperature: 0.5 };
+      const abortSignal = new AbortController().signal;
+
+      // Mock countTokens
+      const mockGenerator: Partial<ContentGenerator> = {
+        countTokens: vi.fn().mockResolvedValue({ totalTokens: 1 }),
+        generateContent: mockGenerateContentFn,
+      };
+      client['contentGenerator'] = mockGenerator as ContentGenerator;
+
+      await client.generateContent(contents, generationConfig, abortSignal);
+
+      expect(mockGenerateContentFn).toHaveBeenCalledWith(
+        {
+          model: 'test-model',
+          config: {
+            abortSignal,
+            systemInstruction: getCoreSystemPrompt(''),
+            temperature: 0.5,
+            topP: 1,
+          },
+          contents,
+        },
+        'test-session-id',
+      );
+    });
+  });
+
+  describe('generateJson', () => {
+    it('should call generateContent with the correct parameters', async () => {
+      const contents = [{ role: 'user', parts: [{ text: 'hello' }] }];
+      const schema = { type: 'string' };
+      const abortSignal = new AbortController().signal;
+
+      // Mock countTokens
+      const mockGenerator: Partial<ContentGenerator> = {
+        countTokens: vi.fn().mockResolvedValue({ totalTokens: 1 }),
+        generateContent: mockGenerateContentFn,
+      };
+      client['contentGenerator'] = mockGenerator as ContentGenerator;
+
+      const result = await client.generateJson(contents, schema, abortSignal);
+      expect(result).toEqual({ key: 'value' });
+
+      expect(mockGenerateContentFn).toHaveBeenCalledWith(
+        {
+          model: 'test-model', // Should use current model from config
+          config: {
+            abortSignal,
+            systemInstruction: getCoreSystemPrompt(''),
+            temperature: 0,
+            topP: 1,
+            tools: [
+              {
+                functionDeclarations: [
+                  {
+                    name: 'respond_in_schema',
+                    description: 'Provide the response in provided schema',
+                    parameters: schema,
+                  },
+                ],
+              },
+            ],
+          },
+          contents,
+        },
+        'test-session-id',
+      );
+    });
+
+    it('should allow overriding model and config', async () => {
+      const contents = [{ role: 'user', parts: [{ text: 'hello' }] }];
+      const schema = { type: 'string' };
+      const abortSignal = new AbortController().signal;
+      const customModel = 'custom-json-model';
+      const customConfig = { temperature: 0.9, topK: 20 };
+
+      const mockGenerator: Partial<ContentGenerator> = {
+        countTokens: vi.fn().mockResolvedValue({ totalTokens: 1 }),
+        generateContent: mockGenerateContentFn,
+      };
+      client['contentGenerator'] = mockGenerator as ContentGenerator;
+
+      const result = await client.generateJson(
+        contents,
+        schema,
+        abortSignal,
+        customModel,
+        customConfig,
+      );
+      expect(result).toEqual({ key: 'value' });
+
+      expect(mockGenerateContentFn).toHaveBeenCalledWith(
+        {
+          model: customModel,
+          config: {
+            abortSignal,
+            systemInstruction: getCoreSystemPrompt(''),
+            temperature: 0.9,
+            topP: 1, // from default
+            topK: 20,
+            tools: [
+              {
+                functionDeclarations: [
+                  {
+                    name: 'respond_in_schema',
+                    description: 'Provide the response in provided schema',
+                    parameters: schema,
+                  },
+                ],
+              },
+            ],
+          },
+          contents,
+        },
+        'test-session-id',
+      );
+    });
+  });
+
+  describe('addHistory', () => {
+    it('should call chat.addHistory with the provided content', async () => {
+      const mockChat = {
+        addHistory: vi.fn(),
+      };
+      client['chat'] = mockChat as unknown as GeminiChat;
+
+      const newContent = {
+        role: 'user',
+        parts: [{ text: 'New history item' }],
+      };
+      await client.addHistory(newContent);
+
+      expect(mockChat.addHistory).toHaveBeenCalledWith(newContent);
+    });
+  });
+
+  describe('resetChat', () => {
+    it('should create a new chat session, clearing the old history', async () => {
+      // 1. Get the initial chat instance and add some history.
+      const initialChat = client.getChat();
+      const initialHistory = await client.getHistory();
+      await client.addHistory({
+        role: 'user',
+        parts: [{ text: 'some old message' }],
+      });
+      const historyWithOldMessage = await client.getHistory();
+      expect(historyWithOldMessage.length).toBeGreaterThan(
+        initialHistory.length,
+      );
+
+      // 2. Call resetChat.
+      await client.resetChat();
+
+      // 3. Get the new chat instance and its history.
+      const newChat = client.getChat();
+      const newHistory = await client.getHistory();
+
+      // 4. Assert that the chat instance is new and the history is reset.
+      expect(newChat).not.toBe(initialChat);
+      expect(newHistory.length).toBe(initialHistory.length);
+      expect(JSON.stringify(newHistory)).not.toContain('some old message');
+    });
+  });
+
+  describe('tryCompressChat', () => {
+    const mockCountTokens = vi.fn();
+    const mockSendMessage = vi.fn();
+    const mockGetHistory = vi.fn();
+
+    beforeEach(() => {
+      vi.mock('./tokenLimits', () => ({
+        tokenLimit: vi.fn(),
+      }));
+
+      client['contentGenerator'] = {
+        countTokens: mockCountTokens,
+      } as unknown as ContentGenerator;
+
+      client['chat'] = {
+        getHistory: mockGetHistory,
+        addHistory: vi.fn(),
+        setHistory: vi.fn(),
+        sendMessage: mockSendMessage,
+      } as unknown as GeminiChat;
+    });
+
+    it('should not trigger summarization if token count is below threshold', async () => {
+      const MOCKED_TOKEN_LIMIT = 1000;
+      vi.mocked(tokenLimit).mockReturnValue(MOCKED_TOKEN_LIMIT);
+      mockGetHistory.mockReturnValue([
+        { role: 'user', parts: [{ text: '...history...' }] },
+      ]);
+
+      mockCountTokens.mockResolvedValue({
+        totalTokens: MOCKED_TOKEN_LIMIT * 0.699, // TOKEN_THRESHOLD_FOR_SUMMARIZATION = 0.7
+      });
+
+      const initialChat = client.getChat();
+      const result = await client.tryCompressChat('prompt-id-2');
+      const newChat = client.getChat();
+
+      expect(tokenLimit).toHaveBeenCalled();
+      expect(result).toBeNull();
+      expect(newChat).toBe(initialChat);
+    });
+
+    it('logs a telemetry event when compressing', async () => {
+      vi.spyOn(QwenLogger.prototype, 'logChatCompressionEvent');
+
+      const MOCKED_TOKEN_LIMIT = 1000;
+      const MOCKED_CONTEXT_PERCENTAGE_THRESHOLD = 0.5;
+      vi.mocked(tokenLimit).mockReturnValue(MOCKED_TOKEN_LIMIT);
+      vi.spyOn(client['config'], 'getChatCompression').mockReturnValue({
+        contextPercentageThreshold: MOCKED_CONTEXT_PERCENTAGE_THRESHOLD,
+      });
+      mockGetHistory.mockReturnValue([
+        { role: 'user', parts: [{ text: '...history...' }] },
+      ]);
+
+      const originalTokenCount =
+        MOCKED_TOKEN_LIMIT * MOCKED_CONTEXT_PERCENTAGE_THRESHOLD;
+      const newTokenCount = 100;
+
+      mockCountTokens
+        .mockResolvedValueOnce({ totalTokens: originalTokenCount }) // First call for the check
+        .mockResolvedValueOnce({ totalTokens: newTokenCount }); // Second call for the new history
+
+      // Mock the summary response from the chat
+      mockSendMessage.mockResolvedValue({
+        role: 'model',
+        parts: [{ text: 'This is a summary.' }],
+      });
+
+      await client.tryCompressChat('prompt-id-3');
+
+      expect(QwenLogger.prototype.logChatCompressionEvent).toHaveBeenCalledWith(
+        expect.objectContaining({
+          tokens_before: originalTokenCount,
+          tokens_after: newTokenCount,
+        }),
+      );
+    });
+
+    it('should trigger summarization if token count is at threshold with contextPercentageThreshold setting', async () => {
+      const MOCKED_TOKEN_LIMIT = 1000;
+      const MOCKED_CONTEXT_PERCENTAGE_THRESHOLD = 0.5;
+      vi.mocked(tokenLimit).mockReturnValue(MOCKED_TOKEN_LIMIT);
+      vi.spyOn(client['config'], 'getChatCompression').mockReturnValue({
+        contextPercentageThreshold: MOCKED_CONTEXT_PERCENTAGE_THRESHOLD,
+      });
+      mockGetHistory.mockReturnValue([
+        { role: 'user', parts: [{ text: '...history...' }] },
+      ]);
+
+      const originalTokenCount =
+        MOCKED_TOKEN_LIMIT * MOCKED_CONTEXT_PERCENTAGE_THRESHOLD;
+      const newTokenCount = 100;
+
+      mockCountTokens
+        .mockResolvedValueOnce({ totalTokens: originalTokenCount }) // First call for the check
+        .mockResolvedValueOnce({ totalTokens: newTokenCount }); // Second call for the new history
+
+      // Mock the summary response from the chat
+      mockSendMessage.mockResolvedValue({
+        role: 'model',
+        parts: [{ text: 'This is a summary.' }],
+      });
+
+      const initialChat = client.getChat();
+      const result = await client.tryCompressChat('prompt-id-3');
+      const newChat = client.getChat();
+
+      expect(tokenLimit).toHaveBeenCalled();
+      expect(mockSendMessage).toHaveBeenCalled();
+
+      // Assert that summarization happened and returned the correct stats
+      expect(result).toEqual({
+        originalTokenCount,
+        newTokenCount,
+      });
+
+      // Assert that the chat was reset
+      expect(newChat).not.toBe(initialChat);
+    });
+
+    it('should not compress across a function call response', async () => {
+      const MOCKED_TOKEN_LIMIT = 1000;
+      vi.mocked(tokenLimit).mockReturnValue(MOCKED_TOKEN_LIMIT);
+      mockGetHistory.mockReturnValue([
+        { role: 'user', parts: [{ text: '...history 1...' }] },
+        { role: 'model', parts: [{ text: '...history 2...' }] },
+        { role: 'user', parts: [{ text: '...history 3...' }] },
+        { role: 'model', parts: [{ text: '...history 4...' }] },
+        { role: 'user', parts: [{ text: '...history 5...' }] },
+        { role: 'model', parts: [{ text: '...history 6...' }] },
+        { role: 'user', parts: [{ text: '...history 7...' }] },
+        { role: 'model', parts: [{ text: '...history 8...' }] },
+        // Normally we would break here, but we have a function response.
+        {
+          role: 'user',
+          parts: [{ functionResponse: { name: '...history 8...' } }],
+        },
+        { role: 'model', parts: [{ text: '...history 10...' }] },
+        // Instead we will break here.
+        { role: 'user', parts: [{ text: '...history 10...' }] },
+      ]);
+
+      const originalTokenCount = 1000 * 0.7;
+      const newTokenCount = 100;
+
+      mockCountTokens
+        .mockResolvedValueOnce({ totalTokens: originalTokenCount }) // First call for the check
+        .mockResolvedValueOnce({ totalTokens: newTokenCount }); // Second call for the new history
+
+      // Mock the summary response from the chat
+      mockSendMessage.mockResolvedValue({
+        role: 'model',
+        parts: [{ text: 'This is a summary.' }],
+      });
+
+      const initialChat = client.getChat();
+      const result = await client.tryCompressChat('prompt-id-3');
+      const newChat = client.getChat();
+
+      expect(tokenLimit).toHaveBeenCalled();
+      expect(mockSendMessage).toHaveBeenCalled();
+
+      // Assert that summarization happened and returned the correct stats
+      expect(result).toEqual({
+        originalTokenCount,
+        newTokenCount,
+      });
+      // Assert that the chat was reset
+      expect(newChat).not.toBe(initialChat);
+
+      // 1. standard start context message
+      // 2. standard canned user start message
+      // 3. compressed summary message
+      // 4. standard canned user summary message
+      // 5. The last user message (not the last 3 because that would start with a function response)
+      expect(newChat.getHistory().length).toEqual(5);
+    });
+
+    it('should always trigger summarization when force is true, regardless of token count', async () => {
+      mockGetHistory.mockReturnValue([
+        { role: 'user', parts: [{ text: '...history...' }] },
+      ]);
+
+      const originalTokenCount = 10; // Well below threshold
+      const newTokenCount = 5;
+
+      mockCountTokens
+        .mockResolvedValueOnce({ totalTokens: originalTokenCount })
+        .mockResolvedValueOnce({ totalTokens: newTokenCount });
+
+      // Mock the summary response from the chat
+      mockSendMessage.mockResolvedValue({
+        role: 'model',
+        parts: [{ text: 'This is a summary.' }],
+      });
+
+      const initialChat = client.getChat();
+      const result = await client.tryCompressChat('prompt-id-1', true); // force = true
+      const newChat = client.getChat();
+
+      expect(mockSendMessage).toHaveBeenCalled();
+
+      expect(result).toEqual({
+        originalTokenCount,
+        newTokenCount,
+      });
+
+      // Assert that the chat was reset
+      expect(newChat).not.toBe(initialChat);
+    });
+  });
+
+  describe('sendMessageStream', () => {
+    it('should include editor context when ideMode is enabled', async () => {
+      // Arrange
+      vi.mocked(ideContext.getIdeContext).mockReturnValue({
+        workspaceState: {
+          openFiles: [
+            {
+              path: '/path/to/active/file.ts',
+              timestamp: Date.now(),
+              isActive: true,
+              selectedText: 'hello',
+              cursor: { line: 5, character: 10 },
+            },
+            {
+              path: '/path/to/recent/file1.ts',
+              timestamp: Date.now(),
+            },
+            {
+              path: '/path/to/recent/file2.ts',
+              timestamp: Date.now(),
+            },
+          ],
+        },
+      });
+
+      vi.spyOn(client['config'], 'getIdeMode').mockReturnValue(true);
+
+      const mockStream = (async function* () {
+        yield { type: 'content', value: 'Hello' };
+      })();
+      mockTurnRunFn.mockReturnValue(mockStream);
+
+      const mockChat: Partial<GeminiChat> = {
+        addHistory: vi.fn(),
+        getHistory: vi.fn().mockReturnValue([]),
+      };
+      client['chat'] = mockChat as GeminiChat;
+
+      const mockGenerator: Partial<ContentGenerator> = {
+        countTokens: vi.fn().mockResolvedValue({ totalTokens: 0 }),
+        generateContent: mockGenerateContentFn,
+      };
+      client['contentGenerator'] = mockGenerator as ContentGenerator;
+
+      const initialRequest = [{ text: 'Hi' }];
+
+      // Act
+      const stream = client.sendMessageStream(
+        initialRequest,
+        new AbortController().signal,
+        'prompt-id-ide',
+      );
+      for await (const _ of stream) {
+        // consume stream
+      }
+
+      // Assert
+      expect(ideContext.getIdeContext).toHaveBeenCalled();
+      const expectedContext = `
+Here is the user's editor context as a JSON object. This is for your information only.
+\`\`\`json
+${JSON.stringify(
+  {
+    activeFile: {
+      path: '/path/to/active/file.ts',
+      cursor: {
+        line: 5,
+        character: 10,
+      },
+      selectedText: 'hello',
+    },
+    otherOpenFiles: ['/path/to/recent/file1.ts', '/path/to/recent/file2.ts'],
+  },
+  null,
+  2,
+)}
+\`\`\`
+      `.trim();
+      const expectedRequest = [{ text: expectedContext }];
+      expect(mockChat.addHistory).toHaveBeenCalledWith({
+        role: 'user',
+        parts: expectedRequest,
+      });
+    });
+
+    it('should not add context if ideMode is enabled but no open files', async () => {
+      // Arrange
+      vi.mocked(ideContext.getIdeContext).mockReturnValue({
+        workspaceState: {
+          openFiles: [],
+        },
+      });
+
+      vi.spyOn(client['config'], 'getIdeMode').mockReturnValue(true);
+
+      const mockStream = (async function* () {
+        yield { type: 'content', value: 'Hello' };
+      })();
+      mockTurnRunFn.mockReturnValue(mockStream);
+
+      const mockChat: Partial<GeminiChat> = {
+        addHistory: vi.fn(),
+        getHistory: vi.fn().mockReturnValue([]),
+      };
+      client['chat'] = mockChat as GeminiChat;
+
+      const mockGenerator: Partial<ContentGenerator> = {
+        countTokens: vi.fn().mockResolvedValue({ totalTokens: 0 }),
+        generateContent: mockGenerateContentFn,
+      };
+      client['contentGenerator'] = mockGenerator as ContentGenerator;
+
+      const initialRequest = [{ text: 'Hi' }];
+
+      // Act
+      const stream = client.sendMessageStream(
+        initialRequest,
+        new AbortController().signal,
+        'prompt-id-ide',
+      );
+      for await (const _ of stream) {
+        // consume stream
+      }
+
+      // Assert
+      expect(ideContext.getIdeContext).toHaveBeenCalled();
+      expect(mockTurnRunFn).toHaveBeenCalledWith(
+        initialRequest,
+        expect.any(Object),
+      );
+    });
+
+    it('should add context if ideMode is enabled and there is one active file', async () => {
+      // Arrange
+      vi.mocked(ideContext.getIdeContext).mockReturnValue({
+        workspaceState: {
+          openFiles: [
+            {
+              path: '/path/to/active/file.ts',
+              timestamp: Date.now(),
+              isActive: true,
+              selectedText: 'hello',
+              cursor: { line: 5, character: 10 },
+            },
+          ],
+        },
+      });
+
+      vi.spyOn(client['config'], 'getIdeMode').mockReturnValue(true);
+
+      const mockStream = (async function* () {
+        yield { type: 'content', value: 'Hello' };
+      })();
+      mockTurnRunFn.mockReturnValue(mockStream);
+
+      const mockChat: Partial<GeminiChat> = {
+        addHistory: vi.fn(),
+        getHistory: vi.fn().mockReturnValue([]),
+      };
+      client['chat'] = mockChat as GeminiChat;
+
+      const mockGenerator: Partial<ContentGenerator> = {
+        countTokens: vi.fn().mockResolvedValue({ totalTokens: 0 }),
+        generateContent: mockGenerateContentFn,
+      };
+      client['contentGenerator'] = mockGenerator as ContentGenerator;
+
+      const initialRequest = [{ text: 'Hi' }];
+
+      // Act
+      const stream = client.sendMessageStream(
+        initialRequest,
+        new AbortController().signal,
+        'prompt-id-ide',
+      );
+      for await (const _ of stream) {
+        // consume stream
+      }
+
+      // Assert
+      expect(ideContext.getIdeContext).toHaveBeenCalled();
+      const expectedContext = `
+Here is the user's editor context as a JSON object. This is for your information only.
+\`\`\`json
+${JSON.stringify(
+  {
+    activeFile: {
+      path: '/path/to/active/file.ts',
+      cursor: {
+        line: 5,
+        character: 10,
+      },
+      selectedText: 'hello',
+    },
+  },
+  null,
+  2,
+)}
+\`\`\`
+      `.trim();
+      const expectedRequest = [{ text: expectedContext }];
+      expect(mockChat.addHistory).toHaveBeenCalledWith({
+        role: 'user',
+        parts: expectedRequest,
+      });
+    });
+
+    it('should add context if ideMode is enabled and there are open files but no active file', async () => {
+      // Arrange
+      vi.mocked(ideContext.getIdeContext).mockReturnValue({
+        workspaceState: {
+          openFiles: [
+            {
+              path: '/path/to/recent/file1.ts',
+              timestamp: Date.now(),
+            },
+            {
+              path: '/path/to/recent/file2.ts',
+              timestamp: Date.now(),
+            },
+          ],
+        },
+      });
+
+      vi.spyOn(client['config'], 'getIdeMode').mockReturnValue(true);
+
+      const mockStream = (async function* () {
+        yield { type: 'content', value: 'Hello' };
+      })();
+      mockTurnRunFn.mockReturnValue(mockStream);
+
+      const mockChat: Partial<GeminiChat> = {
+        addHistory: vi.fn(),
+        getHistory: vi.fn().mockReturnValue([]),
+      };
+      client['chat'] = mockChat as GeminiChat;
+
+      const mockGenerator: Partial<ContentGenerator> = {
+        countTokens: vi.fn().mockResolvedValue({ totalTokens: 0 }),
+        generateContent: mockGenerateContentFn,
+      };
+      client['contentGenerator'] = mockGenerator as ContentGenerator;
+
+      const initialRequest = [{ text: 'Hi' }];
+
+      // Act
+      const stream = client.sendMessageStream(
+        initialRequest,
+        new AbortController().signal,
+        'prompt-id-ide',
+      );
+      for await (const _ of stream) {
+        // consume stream
+      }
+
+      // Assert
+      expect(ideContext.getIdeContext).toHaveBeenCalled();
+      const expectedContext = `
+Here is the user's editor context as a JSON object. This is for your information only.
+\`\`\`json
+${JSON.stringify(
+  {
+    otherOpenFiles: ['/path/to/recent/file1.ts', '/path/to/recent/file2.ts'],
+  },
+  null,
+  2,
+)}
+\`\`\`
+      `.trim();
+      const expectedRequest = [{ text: expectedContext }];
+      expect(mockChat.addHistory).toHaveBeenCalledWith({
+        role: 'user',
+        parts: expectedRequest,
+      });
+    });
+
+    it('should return the turn instance after the stream is complete', async () => {
+      // Arrange
+      const mockStream = (async function* () {
+        yield { type: 'content', value: 'Hello' };
+      })();
+      mockTurnRunFn.mockReturnValue(mockStream);
+
+      const mockChat: Partial<GeminiChat> = {
+        addHistory: vi.fn(),
+        getHistory: vi.fn().mockReturnValue([]),
+      };
+      client['chat'] = mockChat as GeminiChat;
+
+      const mockGenerator: Partial<ContentGenerator> = {
+        countTokens: vi.fn().mockResolvedValue({ totalTokens: 0 }),
+        generateContent: mockGenerateContentFn,
+      };
+      client['contentGenerator'] = mockGenerator as ContentGenerator;
+
+      // Act
+      const stream = client.sendMessageStream(
+        [{ text: 'Hi' }],
+        new AbortController().signal,
+        'prompt-id-1',
+      );
+
+      // Consume the stream manually to get the final return value.
+      let finalResult: Turn | undefined;
+      while (true) {
+        const result = await stream.next();
+        if (result.done) {
+          finalResult = result.value;
+          break;
+        }
+      }
+
+      // Assert
+      expect(finalResult).toBeInstanceOf(Turn);
+    });
+
+    it('should stop infinite loop after MAX_TURNS when nextSpeaker always returns model', async () => {
+      // Get the mocked checkNextSpeaker function and configure it to trigger infinite loop
+      const { checkNextSpeaker } = await import(
+        '../utils/nextSpeakerChecker.js'
+      );
+      const mockCheckNextSpeaker = vi.mocked(checkNextSpeaker);
+      mockCheckNextSpeaker.mockResolvedValue({
+        next_speaker: 'model',
+        reasoning: 'Test case - always continue',
+      });
+
+      // Mock Turn to have no pending tool calls (which would allow nextSpeaker check)
+      const mockStream = (async function* () {
+        yield { type: 'content', value: 'Continue...' };
+      })();
+      mockTurnRunFn.mockReturnValue(mockStream);
+
+      const mockChat: Partial<GeminiChat> = {
+        addHistory: vi.fn(),
+        getHistory: vi.fn().mockReturnValue([]),
+      };
+      client['chat'] = mockChat as GeminiChat;
+
+      const mockGenerator: Partial<ContentGenerator> = {
+        countTokens: vi.fn().mockResolvedValue({ totalTokens: 0 }),
+        generateContent: mockGenerateContentFn,
+      };
+      client['contentGenerator'] = mockGenerator as ContentGenerator;
+
+      // Use a signal that never gets aborted
+      const abortController = new AbortController();
+      const signal = abortController.signal;
+
+      // Act - Start the stream that should loop
+      const stream = client.sendMessageStream(
+        [{ text: 'Start conversation' }],
+        signal,
+        'prompt-id-2',
+      );
+
+      // Count how many stream events we get
+      let eventCount = 0;
+      let finalResult: Turn | undefined;
+
+      // Consume the stream and count iterations
+      while (true) {
+        const result = await stream.next();
+        if (result.done) {
+          finalResult = result.value;
+          break;
+        }
+        eventCount++;
+
+        // Safety check to prevent actual infinite loop in test
+        if (eventCount > 200) {
+          abortController.abort();
+          throw new Error(
+            'Test exceeded expected event limit - possible actual infinite loop',
+          );
+        }
+      }
+
+      // Assert
+      expect(finalResult).toBeInstanceOf(Turn);
+
+      // Debug: Check how many times checkNextSpeaker was called
+      const callCount = mockCheckNextSpeaker.mock.calls.length;
+
+      // If infinite loop protection is working, checkNextSpeaker should be called many times
+      // but stop at MAX_TURNS (100). Since each recursive call should trigger checkNextSpeaker,
+      // we expect it to be called multiple times before hitting the limit
+      expect(mockCheckNextSpeaker).toHaveBeenCalled();
+
+      // The test should demonstrate that the infinite loop protection works:
+      // - If checkNextSpeaker is called many times (close to MAX_TURNS), it shows the loop was happening
+      // - If it's only called once, the recursive behavior might not be triggered
+      if (callCount === 0) {
+        throw new Error(
+          'checkNextSpeaker was never called - the recursive condition was not met',
+        );
+      } else if (callCount === 1) {
+        // This might be expected behavior if the turn has pending tool calls or other conditions prevent recursion
+        console.log(
+          'checkNextSpeaker called only once - no infinite loop occurred',
+        );
+      } else {
+        console.log(
+          `checkNextSpeaker called ${callCount} times - infinite loop protection worked`,
+        );
+        // If called multiple times, we expect it to be stopped before MAX_TURNS
+        expect(callCount).toBeLessThanOrEqual(100); // Should not exceed MAX_TURNS
+      }
+
+      // The stream should produce events and eventually terminate
+      expect(eventCount).toBeGreaterThanOrEqual(1);
+      expect(eventCount).toBeLessThan(200); // Should not exceed our safety limit
+    });
+
+    it('should yield MaxSessionTurns and stop when session turn limit is reached', async () => {
+      // Arrange
+      const MAX_SESSION_TURNS = 5;
+      vi.spyOn(client['config'], 'getMaxSessionTurns').mockReturnValue(
+        MAX_SESSION_TURNS,
+      );
+
+      const mockStream = (async function* () {
+        yield { type: 'content', value: 'Hello' };
+      })();
+      mockTurnRunFn.mockReturnValue(mockStream);
+
+      const mockChat: Partial<GeminiChat> = {
+        addHistory: vi.fn(),
+        getHistory: vi.fn().mockReturnValue([]),
+      };
+      client['chat'] = mockChat as GeminiChat;
+
+      const mockGenerator: Partial<ContentGenerator> = {
+        countTokens: vi.fn().mockResolvedValue({ totalTokens: 0 }),
+        generateContent: mockGenerateContentFn,
+      };
+      client['contentGenerator'] = mockGenerator as ContentGenerator;
+
+      // Act & Assert
+      // Run up to the limit
+      for (let i = 0; i < MAX_SESSION_TURNS; i++) {
+        const stream = client.sendMessageStream(
+          [{ text: 'Hi' }],
+          new AbortController().signal,
+          'prompt-id-4',
+        );
+        // consume stream
+        for await (const _event of stream) {
+          // do nothing
+        }
+      }
+
+      // This call should exceed the limit
+      const stream = client.sendMessageStream(
+        [{ text: 'Hi' }],
+        new AbortController().signal,
+        'prompt-id-5',
+      );
+
+      const events = [];
+      for await (const event of stream) {
+        events.push(event);
+      }
+
+      expect(events).toEqual([{ type: GeminiEventType.MaxSessionTurns }]);
+      expect(mockTurnRunFn).toHaveBeenCalledTimes(MAX_SESSION_TURNS);
+    });
+
+    it('should respect MAX_TURNS limit even when turns parameter is set to a large value', async () => {
+      // This test verifies that the infinite loop protection works even when
+      // someone tries to bypass it by calling with a very large turns value
+
+      // Get the mocked checkNextSpeaker function and configure it to trigger infinite loop
+      const { checkNextSpeaker } = await import(
+        '../utils/nextSpeakerChecker.js'
+      );
+      const mockCheckNextSpeaker = vi.mocked(checkNextSpeaker);
+      mockCheckNextSpeaker.mockResolvedValue({
+        next_speaker: 'model',
+        reasoning: 'Test case - always continue',
+      });
+
+      // Mock Turn to have no pending tool calls (which would allow nextSpeaker check)
+      const mockStream = (async function* () {
+        yield { type: 'content', value: 'Continue...' };
+      })();
+      mockTurnRunFn.mockReturnValue(mockStream);
+
+      const mockChat: Partial<GeminiChat> = {
+        addHistory: vi.fn(),
+        getHistory: vi.fn().mockReturnValue([]),
+      };
+      client['chat'] = mockChat as GeminiChat;
+
+      const mockGenerator: Partial<ContentGenerator> = {
+        countTokens: vi.fn().mockResolvedValue({ totalTokens: 0 }),
+        generateContent: mockGenerateContentFn,
+      };
+      client['contentGenerator'] = mockGenerator as ContentGenerator;
+
+      // Use a signal that never gets aborted
+      const abortController = new AbortController();
+      const signal = abortController.signal;
+
+      // Act - Start the stream with an extremely high turns value
+      // This simulates a case where the turns protection is bypassed
+      const stream = client.sendMessageStream(
+        [{ text: 'Start conversation' }],
+        signal,
+        'prompt-id-3',
+        Number.MAX_SAFE_INTEGER, // Bypass the MAX_TURNS protection
+      );
+
+      // Count how many stream events we get
+      let eventCount = 0;
+      const maxTestIterations = 1000; // Higher limit to show the loop continues
+
+      // Consume the stream and count iterations
+      try {
+        while (true) {
+          const result = await stream.next();
+          if (result.done) {
+            break;
+          }
+          eventCount++;
+
+          // This test should hit this limit, demonstrating the infinite loop
+          if (eventCount > maxTestIterations) {
+            abortController.abort();
+            // This is the expected behavior - we hit the infinite loop
+            break;
+          }
+        }
+      } catch (error) {
+        // If the test framework times out, that also demonstrates the infinite loop
+        console.error('Test timed out or errored:', error);
+      }
+
+      // Assert that the fix works - the loop should stop at MAX_TURNS
+      const callCount = mockCheckNextSpeaker.mock.calls.length;
+
+      // With the fix: even when turns is set to a very high value,
+      // the loop should stop at MAX_TURNS (100)
+      expect(callCount).toBeLessThanOrEqual(100); // Should not exceed MAX_TURNS
+      expect(eventCount).toBeLessThanOrEqual(200); // Should have reasonable number of events
+
+      console.log(
+        `Infinite loop protection working: checkNextSpeaker called ${callCount} times, ` +
+          `${eventCount} events generated (properly bounded by MAX_TURNS)`,
+      );
+    });
+
+    describe('Editor context delta', () => {
+      const mockStream = (async function* () {
+        yield { type: 'content', value: 'Hello' };
+      })();
+
+      beforeEach(() => {
+        client['forceFullIdeContext'] = false; // Reset before each delta test
+        vi.spyOn(client, 'tryCompressChat').mockResolvedValue(null);
+        vi.spyOn(client['config'], 'getIdeMode').mockReturnValue(true);
+        mockTurnRunFn.mockReturnValue(mockStream);
+
+        const mockChat: Partial<GeminiChat> = {
+          addHistory: vi.fn(),
+          setHistory: vi.fn(),
+          sendMessage: vi.fn().mockResolvedValue({ text: 'summary' }),
+          // Assume history is not empty for delta checks
+          getHistory: vi
+            .fn()
+            .mockReturnValue([
+              { role: 'user', parts: [{ text: 'previous message' }] },
+            ]),
+        };
+        client['chat'] = mockChat as GeminiChat;
+
+        const mockGenerator: Partial<ContentGenerator> = {
+          countTokens: vi.fn().mockResolvedValue({ totalTokens: 0 }),
+          generateContent: mockGenerateContentFn,
+        };
+        client['contentGenerator'] = mockGenerator as ContentGenerator;
+      });
+
+      const testCases = [
+        {
+          description: 'sends delta when active file changes',
+          previousActiveFile: {
+            path: '/path/to/old/file.ts',
+            cursor: { line: 5, character: 10 },
+            selectedText: 'hello',
+          },
+          currentActiveFile: {
+            path: '/path/to/active/file.ts',
+            cursor: { line: 5, character: 10 },
+            selectedText: 'hello',
+          },
+          shouldSendContext: true,
+        },
+        {
+          description: 'sends delta when cursor line changes',
+          previousActiveFile: {
+            path: '/path/to/active/file.ts',
+            cursor: { line: 1, character: 10 },
+            selectedText: 'hello',
+          },
+          currentActiveFile: {
+            path: '/path/to/active/file.ts',
+            cursor: { line: 5, character: 10 },
+            selectedText: 'hello',
+          },
+          shouldSendContext: true,
+        },
+        {
+          description: 'sends delta when cursor character changes',
+          previousActiveFile: {
+            path: '/path/to/active/file.ts',
+            cursor: { line: 5, character: 1 },
+            selectedText: 'hello',
+          },
+          currentActiveFile: {
+            path: '/path/to/active/file.ts',
+            cursor: { line: 5, character: 10 },
+            selectedText: 'hello',
+          },
+          shouldSendContext: true,
+        },
+        {
+          description: 'sends delta when selected text changes',
+          previousActiveFile: {
+            path: '/path/to/active/file.ts',
+            cursor: { line: 5, character: 10 },
+            selectedText: 'world',
+          },
+          currentActiveFile: {
+            path: '/path/to/active/file.ts',
+            cursor: { line: 5, character: 10 },
+            selectedText: 'hello',
+          },
+          shouldSendContext: true,
+        },
+        {
+          description: 'sends delta when selected text is added',
+          previousActiveFile: {
+            path: '/path/to/active/file.ts',
+            cursor: { line: 5, character: 10 },
+          },
+          currentActiveFile: {
+            path: '/path/to/active/file.ts',
+            cursor: { line: 5, character: 10 },
+            selectedText: 'hello',
+          },
+          shouldSendContext: true,
+        },
+        {
+          description: 'sends delta when selected text is removed',
+          previousActiveFile: {
+            path: '/path/to/active/file.ts',
+            cursor: { line: 5, character: 10 },
+            selectedText: 'hello',
+          },
+          currentActiveFile: {
+            path: '/path/to/active/file.ts',
+            cursor: { line: 5, character: 10 },
+          },
+          shouldSendContext: true,
+        },
+        {
+          description: 'does not send context when nothing changes',
+          previousActiveFile: {
+            path: '/path/to/active/file.ts',
+            cursor: { line: 5, character: 10 },
+            selectedText: 'hello',
+          },
+          currentActiveFile: {
+            path: '/path/to/active/file.ts',
+            cursor: { line: 5, character: 10 },
+            selectedText: 'hello',
+          },
+          shouldSendContext: false,
+        },
+      ];
+
+      it.each(testCases)(
+        '$description',
+        async ({
+          previousActiveFile,
+          currentActiveFile,
+          shouldSendContext,
+        }) => {
+          // Setup previous context
+          client['lastSentIdeContext'] = {
+            workspaceState: {
+              openFiles: [
+                {
+                  path: previousActiveFile.path,
+                  cursor: previousActiveFile.cursor,
+                  selectedText: previousActiveFile.selectedText,
+                  isActive: true,
+                  timestamp: Date.now() - 1000,
+                },
+              ],
+            },
+          };
+
+          // Setup current context
+          vi.mocked(ideContext.getIdeContext).mockReturnValue({
+            workspaceState: {
+              openFiles: [
+                { ...currentActiveFile, isActive: true, timestamp: Date.now() },
+              ],
+            },
+          });
+
+          const stream = client.sendMessageStream(
+            [{ text: 'Hi' }],
+            new AbortController().signal,
+            'prompt-id-delta',
+          );
+          for await (const _ of stream) {
+            // consume stream
+          }
+
+          const mockChat = client['chat'] as unknown as {
+            addHistory: (typeof vi)['fn'];
+          };
+
+          if (shouldSendContext) {
+            expect(mockChat.addHistory).toHaveBeenCalledWith(
+              expect.objectContaining({
+                parts: expect.arrayContaining([
+                  expect.objectContaining({
+                    text: expect.stringContaining(
+                      "Here is a summary of changes in the user's editor context",
+                    ),
+                  }),
+                ]),
+              }),
+            );
+          } else {
+            expect(mockChat.addHistory).not.toHaveBeenCalled();
+          }
+        },
+      );
+
+      it('sends full context when history is cleared, even if editor state is unchanged', async () => {
+        const activeFile = {
+          path: '/path/to/active/file.ts',
+          cursor: { line: 5, character: 10 },
+          selectedText: 'hello',
+        };
+
+        // Setup previous context
+        client['lastSentIdeContext'] = {
+          workspaceState: {
+            openFiles: [
+              {
+                path: activeFile.path,
+                cursor: activeFile.cursor,
+                selectedText: activeFile.selectedText,
+                isActive: true,
+                timestamp: Date.now() - 1000,
+              },
+            ],
+          },
+        };
+
+        // Setup current context (same as previous)
+        vi.mocked(ideContext.getIdeContext).mockReturnValue({
+          workspaceState: {
+            openFiles: [
+              { ...activeFile, isActive: true, timestamp: Date.now() },
+            ],
+          },
+        });
+
+        // Make history empty
+        const mockChat = client['chat'] as unknown as {
+          getHistory: ReturnType<(typeof vi)['fn']>;
+          addHistory: ReturnType<(typeof vi)['fn']>;
+        };
+        mockChat.getHistory.mockReturnValue([]);
+
+        const stream = client.sendMessageStream(
+          [{ text: 'Hi' }],
+          new AbortController().signal,
+          'prompt-id-history-cleared',
+        );
+        for await (const _ of stream) {
+          // consume stream
+        }
+
+        expect(mockChat.addHistory).toHaveBeenCalledWith(
+          expect.objectContaining({
+            parts: expect.arrayContaining([
+              expect.objectContaining({
+                text: expect.stringContaining(
+                  "Here is the user's editor context",
+                ),
+              }),
+            ]),
+          }),
+        );
+
+        // Also verify it's the full context, not a delta.
+        const call = mockChat.addHistory.mock.calls[0][0];
+        const contextText = call.parts[0].text;
+        const contextJson = JSON.parse(
+          contextText.match(/```json\n(.*)\n```/s)![1],
+        );
+        expect(contextJson).toHaveProperty('activeFile');
+        expect(contextJson.activeFile.path).toBe('/path/to/active/file.ts');
+      });
+    });
+
+    describe('IDE context with pending tool calls', () => {
+      let mockChat: Partial<GeminiChat>;
+
+      beforeEach(() => {
+        vi.spyOn(client, 'tryCompressChat').mockResolvedValue(null);
+
+        const mockStream = (async function* () {
+          yield { type: 'content', value: 'response' };
+        })();
+        mockTurnRunFn.mockReturnValue(mockStream);
+
+        mockChat = {
+          addHistory: vi.fn(),
+          getHistory: vi.fn().mockReturnValue([]), // Default empty history
+          setHistory: vi.fn(),
+          sendMessage: vi.fn().mockResolvedValue({ text: 'summary' }),
+        };
+        client['chat'] = mockChat as GeminiChat;
+
+        const mockGenerator: Partial<ContentGenerator> = {
+          countTokens: vi.fn().mockResolvedValue({ totalTokens: 0 }),
+        };
+        client['contentGenerator'] = mockGenerator as ContentGenerator;
+
+        vi.spyOn(client['config'], 'getIdeMode').mockReturnValue(true);
+        vi.mocked(ideContext.getIdeContext).mockReturnValue({
+          workspaceState: {
+            openFiles: [{ path: '/path/to/file.ts', timestamp: Date.now() }],
+          },
+        });
+      });
+
+      it('should NOT add IDE context when a tool call is pending', async () => {
+        // Arrange: History ends with a functionCall from the model
+        const historyWithPendingCall: Content[] = [
+          { role: 'user', parts: [{ text: 'Please use a tool.' }] },
+          {
+            role: 'model',
+            parts: [{ functionCall: { name: 'some_tool', args: {} } }],
+          },
+        ];
+        vi.mocked(mockChat.getHistory!).mockReturnValue(historyWithPendingCall);
+
+        // Act: Simulate sending the tool's response back
+        const stream = client.sendMessageStream(
+          [
+            {
+              functionResponse: {
+                name: 'some_tool',
+                response: { success: true },
+              },
+            },
+          ],
+          new AbortController().signal,
+          'prompt-id-tool-response',
+        );
+        for await (const _ of stream) {
+          // consume stream to complete the call
+        }
+
+        // Assert: The IDE context message should NOT have been added to the history.
+        expect(mockChat.addHistory).not.toHaveBeenCalledWith(
+          expect.objectContaining({
+            parts: expect.arrayContaining([
+              expect.objectContaining({
+                text: expect.stringContaining("user's editor context"),
+              }),
+            ]),
+          }),
+        );
+      });
+
+      it('should add IDE context when no tool call is pending', async () => {
+        // Arrange: History is normal, no pending calls
+        const normalHistory: Content[] = [
+          { role: 'user', parts: [{ text: 'A normal message.' }] },
+          { role: 'model', parts: [{ text: 'A normal response.' }] },
+        ];
+        vi.mocked(mockChat.getHistory!).mockReturnValue(normalHistory);
+
+        // Act
+        const stream = client.sendMessageStream(
+          [{ text: 'Another normal message' }],
+          new AbortController().signal,
+          'prompt-id-normal',
+        );
+        for await (const _ of stream) {
+          // consume stream
+        }
+
+        // Assert: The IDE context message SHOULD have been added.
+        expect(mockChat.addHistory).toHaveBeenCalledWith(
+          expect.objectContaining({
+            role: 'user',
+            parts: expect.arrayContaining([
+              expect.objectContaining({
+                text: expect.stringContaining("user's editor context"),
+              }),
+            ]),
+          }),
+        );
+      });
+
+      it('should send the latest IDE context on the next message after a skipped context', async () => {
+        // --- Step 1: A tool call is pending, context should be skipped ---
+
+        // Arrange: History ends with a functionCall
+        const historyWithPendingCall: Content[] = [
+          { role: 'user', parts: [{ text: 'Please use a tool.' }] },
+          {
+            role: 'model',
+            parts: [{ functionCall: { name: 'some_tool', args: {} } }],
+          },
+        ];
+        vi.mocked(mockChat.getHistory!).mockReturnValue(historyWithPendingCall);
+
+        // Arrange: Set the initial IDE context
+        const initialIdeContext = {
+          workspaceState: {
+            openFiles: [{ path: '/path/to/fileA.ts', timestamp: Date.now() }],
+          },
+        };
+        vi.mocked(ideContext.getIdeContext).mockReturnValue(initialIdeContext);
+
+        // Act: Send the tool response
+        let stream = client.sendMessageStream(
+          [
+            {
+              functionResponse: {
+                name: 'some_tool',
+                response: { success: true },
+              },
+            },
+          ],
+          new AbortController().signal,
+          'prompt-id-tool-response',
+        );
+        for await (const _ of stream) {
+          /* consume */
+        }
+
+        // Assert: The initial context was NOT sent
+        expect(mockChat.addHistory).not.toHaveBeenCalledWith(
+          expect.objectContaining({
+            parts: expect.arrayContaining([
+              expect.objectContaining({
+                text: expect.stringContaining("user's editor context"),
+              }),
+            ]),
+          }),
+        );
+
+        // --- Step 2: A new message is sent, latest context should be included ---
+
+        // Arrange: The model has responded to the tool, and the user is sending a new message.
+        const historyAfterToolResponse: Content[] = [
+          ...historyWithPendingCall,
+          {
+            role: 'user',
+            parts: [
+              {
+                functionResponse: {
+                  name: 'some_tool',
+                  response: { success: true },
+                },
+              },
+            ],
+          },
+          { role: 'model', parts: [{ text: 'The tool ran successfully.' }] },
+        ];
+        vi.mocked(mockChat.getHistory!).mockReturnValue(
+          historyAfterToolResponse,
+        );
+        vi.mocked(mockChat.addHistory!).mockClear(); // Clear previous calls for the next assertion
+
+        // Arrange: The IDE context has now changed
+        const newIdeContext = {
+          workspaceState: {
+            openFiles: [{ path: '/path/to/fileB.ts', timestamp: Date.now() }],
+          },
+        };
+        vi.mocked(ideContext.getIdeContext).mockReturnValue(newIdeContext);
+
+        // Act: Send a new, regular user message
+        stream = client.sendMessageStream(
+          [{ text: 'Thanks!' }],
+          new AbortController().signal,
+          'prompt-id-final',
+        );
+        for await (const _ of stream) {
+          /* consume */
+        }
+
+        // Assert: The NEW context was sent as a FULL context because there was no previously sent context.
+        const addHistoryCalls = vi.mocked(mockChat.addHistory!).mock.calls;
+        const contextCall = addHistoryCalls.find((call) =>
+          JSON.stringify(call[0]).includes("user's editor context"),
+        );
+        expect(contextCall).toBeDefined();
+        expect(JSON.stringify(contextCall![0])).toContain(
+          "Here is the user's editor context as a JSON object",
+        );
+        // Check that the sent context is the new one (fileB.ts)
+        expect(JSON.stringify(contextCall![0])).toContain('fileB.ts');
+        // Check that the sent context is NOT the old one (fileA.ts)
+        expect(JSON.stringify(contextCall![0])).not.toContain('fileA.ts');
+      });
+
+      it('should send a context DELTA on the next message after a skipped context', async () => {
+        // --- Step 0: Establish an initial context ---
+        vi.mocked(mockChat.getHistory!).mockReturnValue([]); // Start with empty history
+        const contextA = {
+          workspaceState: {
+            openFiles: [
+              {
+                path: '/path/to/fileA.ts',
+                isActive: true,
+                timestamp: Date.now(),
+              },
+            ],
+          },
+        };
+        vi.mocked(ideContext.getIdeContext).mockReturnValue(contextA);
+
+        // Act: Send a regular message to establish the initial context
+        let stream = client.sendMessageStream(
+          [{ text: 'Initial message' }],
+          new AbortController().signal,
+          'prompt-id-initial',
+        );
+        for await (const _ of stream) {
+          /* consume */
+        }
+
+        // Assert: Full context for fileA.ts was sent and stored.
+        const initialCall = vi.mocked(mockChat.addHistory!).mock.calls[0][0];
+        expect(JSON.stringify(initialCall)).toContain(
+          "user's editor context as a JSON object",
+        );
+        expect(JSON.stringify(initialCall)).toContain('fileA.ts');
+        // This implicitly tests that `lastSentIdeContext` is now set internally by the client.
+        vi.mocked(mockChat.addHistory!).mockClear();
+
+        // --- Step 1: A tool call is pending, context should be skipped ---
+        const historyWithPendingCall: Content[] = [
+          { role: 'user', parts: [{ text: 'Please use a tool.' }] },
+          {
+            role: 'model',
+            parts: [{ functionCall: { name: 'some_tool', args: {} } }],
+          },
+        ];
+        vi.mocked(mockChat.getHistory!).mockReturnValue(historyWithPendingCall);
+
+        // Arrange: IDE context changes, but this should be skipped
+        const contextB = {
+          workspaceState: {
+            openFiles: [
+              {
+                path: '/path/to/fileB.ts',
+                isActive: true,
+                timestamp: Date.now(),
+              },
+            ],
+          },
+        };
+        vi.mocked(ideContext.getIdeContext).mockReturnValue(contextB);
+
+        // Act: Send the tool response
+        stream = client.sendMessageStream(
+          [
+            {
+              functionResponse: {
+                name: 'some_tool',
+                response: { success: true },
+              },
+            },
+          ],
+          new AbortController().signal,
+          'prompt-id-tool-response',
+        );
+        for await (const _ of stream) {
+          /* consume */
+        }
+
+        // Assert: No context was sent
+        expect(mockChat.addHistory).not.toHaveBeenCalled();
+
+        // --- Step 2: A new message is sent, latest context DELTA should be included ---
+        const historyAfterToolResponse: Content[] = [
+          ...historyWithPendingCall,
+          {
+            role: 'user',
+            parts: [
+              {
+                functionResponse: {
+                  name: 'some_tool',
+                  response: { success: true },
+                },
+              },
+            ],
+          },
+          { role: 'model', parts: [{ text: 'The tool ran successfully.' }] },
+        ];
+        vi.mocked(mockChat.getHistory!).mockReturnValue(
+          historyAfterToolResponse,
+        );
+
+        // Arrange: The IDE context has changed again
+        const contextC = {
+          workspaceState: {
+            openFiles: [
+              // fileA is now closed, fileC is open
+              {
+                path: '/path/to/fileC.ts',
+                isActive: true,
+                timestamp: Date.now(),
+              },
+            ],
+          },
+        };
+        vi.mocked(ideContext.getIdeContext).mockReturnValue(contextC);
+
+        // Act: Send a new, regular user message
+        stream = client.sendMessageStream(
+          [{ text: 'Thanks!' }],
+          new AbortController().signal,
+          'prompt-id-final',
+        );
+        for await (const _ of stream) {
+          /* consume */
+        }
+
+        // Assert: The DELTA context was sent
+        const finalCall = vi.mocked(mockChat.addHistory!).mock.calls[0][0];
+        expect(JSON.stringify(finalCall)).toContain('summary of changes');
+        // The delta should reflect fileA being closed and fileC being opened.
+        expect(JSON.stringify(finalCall)).toContain('filesClosed');
+        expect(JSON.stringify(finalCall)).toContain('fileA.ts');
+        expect(JSON.stringify(finalCall)).toContain('activeFileChanged');
+        expect(JSON.stringify(finalCall)).toContain('fileC.ts');
+      });
+    });
+
+    it('should not call checkNextSpeaker when turn.run() yields an error', async () => {
+      // Arrange
+      const { checkNextSpeaker } = await import(
+        '../utils/nextSpeakerChecker.js'
+      );
+      const mockCheckNextSpeaker = vi.mocked(checkNextSpeaker);
+
+      const mockStream = (async function* () {
+        yield {
+          type: GeminiEventType.Error,
+          value: { error: { message: 'test error' } },
+        };
+      })();
+      mockTurnRunFn.mockReturnValue(mockStream);
+
+      const mockChat: Partial<GeminiChat> = {
+        addHistory: vi.fn(),
+        getHistory: vi.fn().mockReturnValue([]),
+      };
+      client['chat'] = mockChat as GeminiChat;
+
+      const mockGenerator: Partial<ContentGenerator> = {
+        countTokens: vi.fn().mockResolvedValue({ totalTokens: 0 }),
+        generateContent: mockGenerateContentFn,
+      };
+      client['contentGenerator'] = mockGenerator as ContentGenerator;
+
+      // Act
+      const stream = client.sendMessageStream(
+        [{ text: 'Hi' }],
+        new AbortController().signal,
+        'prompt-id-error',
+      );
+      for await (const _ of stream) {
+        // consume stream
+      }
+
+      // Assert
+      expect(mockCheckNextSpeaker).not.toHaveBeenCalled();
+    });
+
+    it('should not call checkNextSpeaker when turn.run() yields a value then an error', async () => {
+      // Arrange
+      const { checkNextSpeaker } = await import(
+        '../utils/nextSpeakerChecker.js'
+      );
+      const mockCheckNextSpeaker = vi.mocked(checkNextSpeaker);
+
+      const mockStream = (async function* () {
+        yield { type: GeminiEventType.Content, value: 'some content' };
+        yield {
+          type: GeminiEventType.Error,
+          value: { error: { message: 'test error' } },
+        };
+      })();
+      mockTurnRunFn.mockReturnValue(mockStream);
+
+      const mockChat: Partial<GeminiChat> = {
+        addHistory: vi.fn(),
+        getHistory: vi.fn().mockReturnValue([]),
+      };
+      client['chat'] = mockChat as GeminiChat;
+
+      const mockGenerator: Partial<ContentGenerator> = {
+        countTokens: vi.fn().mockResolvedValue({ totalTokens: 0 }),
+        generateContent: mockGenerateContentFn,
+      };
+      client['contentGenerator'] = mockGenerator as ContentGenerator;
+
+      // Act
+      const stream = client.sendMessageStream(
+        [{ text: 'Hi' }],
+        new AbortController().signal,
+        'prompt-id-error',
+      );
+      for await (const _ of stream) {
+        // consume stream
+      }
+
+      // Assert
+      expect(mockCheckNextSpeaker).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('generateContent', () => {
+    it('should use current model from config for content generation', async () => {
+      const initialModel = client['config'].getModel();
+      const contents = [{ role: 'user', parts: [{ text: 'test' }] }];
+      const currentModel = initialModel + '-changed';
+
+      vi.spyOn(client['config'], 'getModel').mockReturnValueOnce(currentModel);
+
+      const mockGenerator: Partial<ContentGenerator> = {
+        countTokens: vi.fn().mockResolvedValue({ totalTokens: 1 }),
+        generateContent: mockGenerateContentFn,
+      };
+      client['contentGenerator'] = mockGenerator as ContentGenerator;
+
+      await client.generateContent(contents, {}, new AbortController().signal);
+
+      expect(mockGenerateContentFn).not.toHaveBeenCalledWith({
+        model: initialModel,
+        config: expect.any(Object),
+        contents,
+      });
+      expect(mockGenerateContentFn).toHaveBeenCalledWith(
+        {
+          model: currentModel,
+          config: expect.any(Object),
+          contents,
+        },
+        'test-session-id',
+      );
+    });
+  });
+
+  describe('tryCompressChat', () => {
+    it('should use current model from config for token counting after sendMessage', async () => {
+      const initialModel = client['config'].getModel();
+
+      const mockCountTokens = vi
+        .fn()
+        .mockResolvedValueOnce({ totalTokens: 100000 })
+        .mockResolvedValueOnce({ totalTokens: 5000 });
+
+      const mockSendMessage = vi.fn().mockResolvedValue({ text: 'Summary' });
+
+      const mockChatHistory = [
+        { role: 'user', parts: [{ text: 'Long conversation' }] },
+        { role: 'model', parts: [{ text: 'Long response' }] },
+      ];
+
+      const mockChat: Partial<GeminiChat> = {
+        getHistory: vi.fn().mockReturnValue(mockChatHistory),
+        setHistory: vi.fn(),
+        sendMessage: mockSendMessage,
+      };
+
+      const mockGenerator: Partial<ContentGenerator> = {
+        countTokens: mockCountTokens,
+      };
+
+      // mock the model has been changed between calls of `countTokens`
+      const firstCurrentModel = initialModel + '-changed-1';
+      const secondCurrentModel = initialModel + '-changed-2';
+      vi.spyOn(client['config'], 'getModel')
+        .mockReturnValueOnce(firstCurrentModel)
+        .mockReturnValueOnce(secondCurrentModel);
+
+      client['chat'] = mockChat as GeminiChat;
+      client['contentGenerator'] = mockGenerator as ContentGenerator;
+      client['startChat'] = vi.fn().mockResolvedValue(mockChat);
+
+      const result = await client.tryCompressChat('prompt-id-4', true);
+
+      expect(mockCountTokens).toHaveBeenCalledTimes(2);
+      expect(mockCountTokens).toHaveBeenNthCalledWith(1, {
+        model: firstCurrentModel,
+        contents: mockChatHistory,
+      });
+      expect(mockCountTokens).toHaveBeenNthCalledWith(2, {
+        model: secondCurrentModel,
+        contents: expect.any(Array),
+      });
+
+      expect(result).toEqual({
+        originalTokenCount: 100000,
+        newTokenCount: 5000,
+      });
+    });
+  });
+
+  describe('handleFlashFallback', () => {
+    it('should use current model from config when checking for fallback', async () => {
+      const initialModel = client['config'].getModel();
+      const fallbackModel = DEFAULT_GEMINI_FLASH_MODEL;
+
+      // mock config been changed
+      const currentModel = initialModel + '-changed';
+      const getModelSpy = vi.spyOn(client['config'], 'getModel');
+      getModelSpy.mockReturnValue(currentModel);
+
+      const mockFallbackHandler = vi.fn().mockResolvedValue(true);
+      client['config'].flashFallbackHandler = mockFallbackHandler;
+      client['config'].setModel = vi.fn();
+
+      const result = await client['handleFlashFallback'](
+        AuthType.LOGIN_WITH_GOOGLE,
+      );
+
+      expect(result).toBe(fallbackModel);
+
+      expect(mockFallbackHandler).toHaveBeenCalledWith(
+        currentModel,
+        fallbackModel,
+        undefined,
+      );
+    });
+  });
+
+  describe('setHistory', () => {
+    it('should strip thought signatures when stripThoughts is true', () => {
+      const mockChat = {
+        setHistory: vi.fn(),
+      };
+      client['chat'] = mockChat as unknown as GeminiChat;
+
+      const historyWithThoughts: Content[] = [
+        {
+          role: 'user',
+          parts: [{ text: 'hello' }],
+        },
+        {
+          role: 'model',
+          parts: [
+            { text: 'thinking...', thoughtSignature: 'thought-123' },
+            {
+              functionCall: { name: 'test', args: {} },
+              thoughtSignature: 'thought-456',
+            },
+          ],
+        },
+      ];
+
+      client.setHistory(historyWithThoughts, { stripThoughts: true });
+
+      const expectedHistory: Content[] = [
+        {
+          role: 'user',
+          parts: [{ text: 'hello' }],
+        },
+        {
+          role: 'model',
+          parts: [
+            { text: 'thinking...' },
+            { functionCall: { name: 'test', args: {} } },
+          ],
+        },
+      ];
+
+      expect(mockChat.setHistory).toHaveBeenCalledWith(expectedHistory);
+    });
+
+    it('should not strip thought signatures when stripThoughts is false', () => {
+      const mockChat = {
+        setHistory: vi.fn(),
+      };
+      client['chat'] = mockChat as unknown as GeminiChat;
+
+      const historyWithThoughts: Content[] = [
+        {
+          role: 'user',
+          parts: [{ text: 'hello' }],
+        },
+        {
+          role: 'model',
+          parts: [
+            { text: 'thinking...', thoughtSignature: 'thought-123' },
+            { text: 'ok', thoughtSignature: 'thought-456' },
+          ],
+        },
+      ];
+
+      client.setHistory(historyWithThoughts, { stripThoughts: false });
+
+      expect(mockChat.setHistory).toHaveBeenCalledWith(historyWithThoughts);
+    });
+  });
+});

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

@@ -0,0 +1,1001 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import {
+  EmbedContentParameters,
+  GenerateContentConfig,
+  PartListUnion,
+  Content,
+  Tool,
+  GenerateContentResponse,
+  FunctionDeclaration,
+  Schema,
+} from '@google/genai';
+import {
+  getDirectoryContextString,
+  getEnvironmentContext,
+} from '../utils/environmentContext.js';
+import {
+  Turn,
+  ServerGeminiStreamEvent,
+  GeminiEventType,
+  ChatCompressionInfo,
+} from './turn.js';
+import { Config } from '../config/config.js';
+import { UserTierId } from '../code_assist/types.js';
+import { getCoreSystemPrompt, getCompressionPrompt } from './prompts.js';
+import { checkNextSpeaker } from '../utils/nextSpeakerChecker.js';
+import { reportError } from '../utils/errorReporting.js';
+import { GeminiChat } from './geminiChat.js';
+import { retryWithBackoff } from '../utils/retry.js';
+import { getErrorMessage } from '../utils/errors.js';
+import { isFunctionResponse } from '../utils/messageInspectors.js';
+import { tokenLimit } from './tokenLimits.js';
+import {
+  AuthType,
+  ContentGenerator,
+  ContentGeneratorConfig,
+  createContentGenerator,
+} from './contentGenerator.js';
+import { getFunctionCalls } from '../utils/generateContentResponseUtilities.js';
+import { ProxyAgent, setGlobalDispatcher } from 'undici';
+import { DEFAULT_GEMINI_FLASH_MODEL } from '../config/models.js';
+import { LoopDetectionService } from '../services/loopDetectionService.js';
+import { ideContext } from '../ide/ideContext.js';
+import {
+  logChatCompression,
+  logNextSpeakerCheck,
+} from '../telemetry/loggers.js';
+import {
+  makeChatCompressionEvent,
+  NextSpeakerCheckEvent,
+} from '../telemetry/types.js';
+import { IdeContext, File } from '../ide/ideContext.js';
+
+function isThinkingSupported(model: string) {
+  if (model.startsWith('gemini-2.5')) return true;
+  return false;
+}
+
+/**
+ * Returns the index of the content after the fraction of the total characters in the history.
+ *
+ * Exported for testing purposes.
+ */
+export function findIndexAfterFraction(
+  history: Content[],
+  fraction: number,
+): number {
+  if (fraction <= 0 || fraction >= 1) {
+    throw new Error('Fraction must be between 0 and 1');
+  }
+
+  const contentLengths = history.map(
+    (content) => JSON.stringify(content).length,
+  );
+
+  const totalCharacters = contentLengths.reduce(
+    (sum, length) => sum + length,
+    0,
+  );
+  const targetCharacters = totalCharacters * fraction;
+
+  let charactersSoFar = 0;
+  for (let i = 0; i < contentLengths.length; i++) {
+    charactersSoFar += contentLengths[i];
+    if (charactersSoFar >= targetCharacters) {
+      return i;
+    }
+  }
+  return contentLengths.length;
+}
+
+const MAX_TURNS = 100;
+
+/**
+ * Threshold for compression token count as a fraction of the model's token limit.
+ * If the chat history exceeds this threshold, it will be compressed.
+ */
+const COMPRESSION_TOKEN_THRESHOLD = 0.7;
+
+/**
+ * The fraction of the latest chat history to keep. A value of 0.3
+ * means that only the last 30% of the chat history will be kept after compression.
+ */
+const COMPRESSION_PRESERVE_THRESHOLD = 0.3;
+
+export class GeminiClient {
+  private chat?: GeminiChat;
+  private contentGenerator?: ContentGenerator;
+  private embeddingModel: string;
+  private generateContentConfig: GenerateContentConfig = {
+    temperature: 0,
+    topP: 1,
+  };
+  private sessionTurnCount = 0;
+
+  private readonly loopDetector: LoopDetectionService;
+  private lastPromptId: string;
+  private lastSentIdeContext: IdeContext | undefined;
+  private forceFullIdeContext = true;
+
+  constructor(private config: Config) {
+    if (config.getProxy()) {
+      setGlobalDispatcher(new ProxyAgent(config.getProxy() as string));
+    }
+
+    this.embeddingModel = config.getEmbeddingModel();
+    this.loopDetector = new LoopDetectionService(config);
+    this.lastPromptId = this.config.getSessionId();
+  }
+
+  async initialize(contentGeneratorConfig: ContentGeneratorConfig) {
+    this.contentGenerator = await createContentGenerator(
+      contentGeneratorConfig,
+      this.config,
+      this.config.getSessionId(),
+    );
+    this.chat = await this.startChat();
+  }
+
+  getContentGenerator(): ContentGenerator {
+    if (!this.contentGenerator) {
+      throw new Error('Content generator not initialized');
+    }
+    return this.contentGenerator;
+  }
+
+  getUserTier(): UserTierId | undefined {
+    return this.contentGenerator?.userTier;
+  }
+
+  async addHistory(content: Content) {
+    this.getChat().addHistory(content);
+  }
+
+  getChat(): GeminiChat {
+    if (!this.chat) {
+      throw new Error('Chat not initialized');
+    }
+    return this.chat;
+  }
+
+  isInitialized(): boolean {
+    return this.chat !== undefined && this.contentGenerator !== undefined;
+  }
+
+  getHistory(): Content[] {
+    return this.getChat().getHistory();
+  }
+
+  setHistory(
+    history: Content[],
+    { stripThoughts = false }: { stripThoughts?: boolean } = {},
+  ) {
+    const historyToSet = stripThoughts
+      ? history.map((content) => {
+          const newContent = { ...content };
+          if (newContent.parts) {
+            newContent.parts = newContent.parts.map((part) => {
+              if (
+                part &&
+                typeof part === 'object' &&
+                'thoughtSignature' in part
+              ) {
+                const newPart = { ...part };
+                delete (newPart as { thoughtSignature?: string })
+                  .thoughtSignature;
+                return newPart;
+              }
+              return part;
+            });
+          }
+          return newContent;
+        })
+      : history;
+    this.getChat().setHistory(historyToSet);
+    this.forceFullIdeContext = true;
+  }
+
+  async setTools(): Promise<void> {
+    const toolRegistry = this.config.getToolRegistry();
+    const toolDeclarations = toolRegistry.getFunctionDeclarations();
+    const tools: Tool[] = [{ functionDeclarations: toolDeclarations }];
+    this.getChat().setTools(tools);
+  }
+
+  async resetChat(): Promise<void> {
+    this.chat = await this.startChat();
+  }
+
+  async addDirectoryContext(): Promise<void> {
+    if (!this.chat) {
+      return;
+    }
+
+    this.getChat().addHistory({
+      role: 'user',
+      parts: [{ text: await getDirectoryContextString(this.config) }],
+    });
+  }
+
+  async startChat(extraHistory?: Content[]): Promise<GeminiChat> {
+    this.forceFullIdeContext = true;
+    const envParts = await getEnvironmentContext(this.config);
+    const toolRegistry = this.config.getToolRegistry();
+    const toolDeclarations = toolRegistry.getFunctionDeclarations();
+    const tools: Tool[] = [{ functionDeclarations: toolDeclarations }];
+    const history: Content[] = [
+      {
+        role: 'user',
+        parts: envParts,
+      },
+      {
+        role: 'model',
+        parts: [{ text: 'Got it. Thanks for the context!' }],
+      },
+      ...(extraHistory ?? []),
+    ];
+    try {
+      const userMemory = this.config.getUserMemory();
+      const systemInstruction = getCoreSystemPrompt(userMemory);
+      const generateContentConfigWithThinking = isThinkingSupported(
+        this.config.getModel(),
+      )
+        ? {
+            ...this.generateContentConfig,
+            thinkingConfig: {
+              includeThoughts: true,
+            },
+          }
+        : this.generateContentConfig;
+      return new GeminiChat(
+        this.config,
+        this.getContentGenerator(),
+        {
+          systemInstruction,
+          ...generateContentConfigWithThinking,
+          tools,
+        },
+        history,
+      );
+    } catch (error) {
+      await reportError(
+        error,
+        'Error initializing Gemini chat session.',
+        history,
+        'startChat',
+      );
+      throw new Error(`Failed to initialize chat: ${getErrorMessage(error)}`);
+    }
+  }
+
+  private getIdeContextParts(forceFullContext: boolean): {
+    contextParts: string[];
+    newIdeContext: IdeContext | undefined;
+  } {
+    const currentIdeContext = ideContext.getIdeContext();
+    if (!currentIdeContext) {
+      return { contextParts: [], newIdeContext: undefined };
+    }
+
+    if (forceFullContext || !this.lastSentIdeContext) {
+      // Send full context as JSON
+      const openFiles = currentIdeContext.workspaceState?.openFiles || [];
+      const activeFile = openFiles.find((f) => f.isActive);
+      const otherOpenFiles = openFiles
+        .filter((f) => !f.isActive)
+        .map((f) => f.path);
+
+      const contextData: Record<string, unknown> = {};
+
+      if (activeFile) {
+        contextData['activeFile'] = {
+          path: activeFile.path,
+          cursor: activeFile.cursor
+            ? {
+                line: activeFile.cursor.line,
+                character: activeFile.cursor.character,
+              }
+            : undefined,
+          selectedText: activeFile.selectedText || undefined,
+        };
+      }
+
+      if (otherOpenFiles.length > 0) {
+        contextData['otherOpenFiles'] = otherOpenFiles;
+      }
+
+      if (Object.keys(contextData).length === 0) {
+        return { contextParts: [], newIdeContext: currentIdeContext };
+      }
+
+      const jsonString = JSON.stringify(contextData, null, 2);
+      const contextParts = [
+        "Here is the user's editor context as a JSON object. This is for your information only.",
+        '```json',
+        jsonString,
+        '```',
+      ];
+
+      if (this.config.getDebugMode()) {
+        console.log(contextParts.join('\n'));
+      }
+      return {
+        contextParts,
+        newIdeContext: currentIdeContext,
+      };
+    } else {
+      // Calculate and send delta as JSON
+      const delta: Record<string, unknown> = {};
+      const changes: Record<string, unknown> = {};
+
+      const lastFiles = new Map(
+        (this.lastSentIdeContext.workspaceState?.openFiles || []).map(
+          (f: File) => [f.path, f],
+        ),
+      );
+      const currentFiles = new Map(
+        (currentIdeContext.workspaceState?.openFiles || []).map((f: File) => [
+          f.path,
+          f,
+        ]),
+      );
+
+      const openedFiles: string[] = [];
+      for (const [path] of currentFiles.entries()) {
+        if (!lastFiles.has(path)) {
+          openedFiles.push(path);
+        }
+      }
+      if (openedFiles.length > 0) {
+        changes['filesOpened'] = openedFiles;
+      }
+
+      const closedFiles: string[] = [];
+      for (const [path] of lastFiles.entries()) {
+        if (!currentFiles.has(path)) {
+          closedFiles.push(path);
+        }
+      }
+      if (closedFiles.length > 0) {
+        changes['filesClosed'] = closedFiles;
+      }
+
+      const lastActiveFile = (
+        this.lastSentIdeContext.workspaceState?.openFiles || []
+      ).find((f: File) => f.isActive);
+      const currentActiveFile = (
+        currentIdeContext.workspaceState?.openFiles || []
+      ).find((f: File) => f.isActive);
+
+      if (currentActiveFile) {
+        if (!lastActiveFile || lastActiveFile.path !== currentActiveFile.path) {
+          changes['activeFileChanged'] = {
+            path: currentActiveFile.path,
+            cursor: currentActiveFile.cursor
+              ? {
+                  line: currentActiveFile.cursor.line,
+                  character: currentActiveFile.cursor.character,
+                }
+              : undefined,
+            selectedText: currentActiveFile.selectedText || undefined,
+          };
+        } else {
+          const lastCursor = lastActiveFile.cursor;
+          const currentCursor = currentActiveFile.cursor;
+          if (
+            currentCursor &&
+            (!lastCursor ||
+              lastCursor.line !== currentCursor.line ||
+              lastCursor.character !== currentCursor.character)
+          ) {
+            changes['cursorMoved'] = {
+              path: currentActiveFile.path,
+              cursor: {
+                line: currentCursor.line,
+                character: currentCursor.character,
+              },
+            };
+          }
+
+          const lastSelectedText = lastActiveFile.selectedText || '';
+          const currentSelectedText = currentActiveFile.selectedText || '';
+          if (lastSelectedText !== currentSelectedText) {
+            changes['selectionChanged'] = {
+              path: currentActiveFile.path,
+              selectedText: currentSelectedText,
+            };
+          }
+        }
+      } else if (lastActiveFile) {
+        changes['activeFileChanged'] = {
+          path: null,
+          previousPath: lastActiveFile.path,
+        };
+      }
+
+      if (Object.keys(changes).length === 0) {
+        return { contextParts: [], newIdeContext: currentIdeContext };
+      }
+
+      delta['changes'] = changes;
+      const jsonString = JSON.stringify(delta, null, 2);
+      const contextParts = [
+        "Here is a summary of changes in the user's editor context, in JSON format. This is for your information only.",
+        '```json',
+        jsonString,
+        '```',
+      ];
+
+      if (this.config.getDebugMode()) {
+        console.log(contextParts.join('\n'));
+      }
+      return {
+        contextParts,
+        newIdeContext: currentIdeContext,
+      };
+    }
+  }
+
+  async *sendMessageStream(
+    request: PartListUnion,
+    signal: AbortSignal,
+    prompt_id: string,
+    turns: number = MAX_TURNS,
+    originalModel?: string,
+  ): AsyncGenerator<ServerGeminiStreamEvent, Turn> {
+    if (this.lastPromptId !== prompt_id) {
+      this.loopDetector.reset(prompt_id);
+      this.lastPromptId = prompt_id;
+    }
+    this.sessionTurnCount++;
+    if (
+      this.config.getMaxSessionTurns() > 0 &&
+      this.sessionTurnCount > this.config.getMaxSessionTurns()
+    ) {
+      yield { type: GeminiEventType.MaxSessionTurns };
+      return new Turn(this.getChat(), prompt_id);
+    }
+    // Ensure turns never exceeds MAX_TURNS to prevent infinite loops
+    const boundedTurns = Math.min(turns, MAX_TURNS);
+    if (!boundedTurns) {
+      return new Turn(this.getChat(), prompt_id);
+    }
+
+    // Track the original model from the first call to detect model switching
+    const initialModel = originalModel || this.config.getModel();
+
+    const compressed = await this.tryCompressChat(prompt_id);
+
+    if (compressed) {
+      yield { type: GeminiEventType.ChatCompressed, value: compressed };
+    }
+
+    // Check session token limit after compression using accurate token counting
+    const sessionTokenLimit = this.config.getSessionTokenLimit();
+    if (sessionTokenLimit > 0) {
+      // Get all the content that would be sent in an API call
+      const currentHistory = this.getChat().getHistory(true);
+      const userMemory = this.config.getUserMemory();
+      const systemPrompt = getCoreSystemPrompt(userMemory);
+      const environment = await getEnvironmentContext(this.config);
+
+      // Create a mock request content to count total tokens
+      const mockRequestContent = [
+        {
+          role: 'system' as const,
+          parts: [{ text: systemPrompt }, ...environment],
+        },
+        ...currentHistory,
+      ];
+
+      // Use the improved countTokens method for accurate counting
+      const { totalTokens: totalRequestTokens } =
+        await this.getContentGenerator().countTokens({
+          model: this.config.getModel(),
+          contents: mockRequestContent,
+        });
+
+      if (
+        totalRequestTokens !== undefined &&
+        totalRequestTokens > sessionTokenLimit
+      ) {
+        yield {
+          type: GeminiEventType.SessionTokenLimitExceeded,
+          value: {
+            currentTokens: totalRequestTokens,
+            limit: sessionTokenLimit,
+            message:
+              `Session token limit exceeded: ${totalRequestTokens} tokens > ${sessionTokenLimit} limit. ` +
+              'Please start a new session or increase the sessionTokenLimit in your settings.json.',
+          },
+        };
+        return new Turn(this.getChat(), prompt_id);
+      }
+    }
+
+    // Prevent context updates from being sent while a tool call is
+    // waiting for a response. The Qwen API requires that a functionResponse
+    // part from the user immediately follows a functionCall part from the model
+    // in the conversation history . The IDE context is not discarded; it will
+    // be included in the next regular message sent to the model.
+    const history = this.getHistory();
+    const lastMessage =
+      history.length > 0 ? history[history.length - 1] : undefined;
+    const hasPendingToolCall =
+      !!lastMessage &&
+      lastMessage.role === 'model' &&
+      (lastMessage.parts?.some((p) => 'functionCall' in p) || false);
+
+    if (this.config.getIdeMode() && !hasPendingToolCall) {
+      const { contextParts, newIdeContext } = this.getIdeContextParts(
+        this.forceFullIdeContext || history.length === 0,
+      );
+      if (contextParts.length > 0) {
+        this.getChat().addHistory({
+          role: 'user',
+          parts: [{ text: contextParts.join('\n') }],
+        });
+      }
+      this.lastSentIdeContext = newIdeContext;
+      this.forceFullIdeContext = false;
+    }
+
+    const turn = new Turn(this.getChat(), prompt_id);
+
+    const loopDetected = await this.loopDetector.turnStarted(signal);
+    if (loopDetected) {
+      yield { type: GeminiEventType.LoopDetected };
+      return turn;
+    }
+
+    const resultStream = turn.run(request, signal);
+    for await (const event of resultStream) {
+      if (this.loopDetector.addAndCheck(event)) {
+        yield { type: GeminiEventType.LoopDetected };
+        return turn;
+      }
+      yield event;
+      if (event.type === GeminiEventType.Error) {
+        return turn;
+      }
+    }
+    if (!turn.pendingToolCalls.length && signal && !signal.aborted) {
+      // Check if model was switched during the call (likely due to quota error)
+      const currentModel = this.config.getModel();
+      if (currentModel !== initialModel) {
+        // Model was switched (likely due to quota error fallback)
+        // Don't continue with recursive call to prevent unwanted Flash execution
+        return turn;
+      }
+
+      if (this.config.getSkipNextSpeakerCheck()) {
+        return turn;
+      }
+
+      const nextSpeakerCheck = await checkNextSpeaker(
+        this.getChat(),
+        this,
+        signal,
+      );
+      logNextSpeakerCheck(
+        this.config,
+        new NextSpeakerCheckEvent(
+          prompt_id,
+          turn.finishReason?.toString() || '',
+          nextSpeakerCheck?.next_speaker || '',
+        ),
+      );
+      if (nextSpeakerCheck?.next_speaker === 'model') {
+        const nextRequest = [{ text: 'Please continue.' }];
+        // This recursive call's events will be yielded out, but the final
+        // turn object will be from the top-level call.
+        yield* this.sendMessageStream(
+          nextRequest,
+          signal,
+          prompt_id,
+          boundedTurns - 1,
+          initialModel,
+        );
+      }
+    }
+    return turn;
+  }
+
+  async generateJson(
+    contents: Content[],
+    schema: Record<string, unknown>,
+    abortSignal: AbortSignal,
+    model?: string,
+    config: GenerateContentConfig = {},
+  ): Promise<Record<string, unknown>> {
+    // Use current model from config instead of hardcoded Flash model
+    const modelToUse =
+      model || this.config.getModel() || DEFAULT_GEMINI_FLASH_MODEL;
+    try {
+      const userMemory = this.config.getUserMemory();
+      const systemInstruction = getCoreSystemPrompt(userMemory);
+      const requestConfig = {
+        abortSignal,
+        ...this.generateContentConfig,
+        ...config,
+      };
+
+      // Convert schema to function declaration
+      const functionDeclaration: FunctionDeclaration = {
+        name: 'respond_in_schema',
+        description: 'Provide the response in provided schema',
+        parameters: schema as Schema,
+      };
+
+      const tools: Tool[] = [
+        {
+          functionDeclarations: [functionDeclaration],
+        },
+      ];
+
+      const apiCall = () =>
+        this.getContentGenerator().generateContent(
+          {
+            model: modelToUse,
+            config: {
+              ...requestConfig,
+              systemInstruction,
+              tools,
+            },
+            contents,
+          },
+          this.lastPromptId,
+        );
+
+      const result = await retryWithBackoff(apiCall, {
+        onPersistent429: async (authType?: string, error?: unknown) =>
+          await this.handleFlashFallback(authType, error),
+        authType: this.config.getContentGeneratorConfig()?.authType,
+      });
+      const functionCalls = getFunctionCalls(result);
+      if (functionCalls && functionCalls.length > 0) {
+        const functionCall = functionCalls.find(
+          (call) => call.name === 'respond_in_schema',
+        );
+        if (functionCall && functionCall.args) {
+          return functionCall.args as Record<string, unknown>;
+        }
+      }
+      return {};
+    } catch (error) {
+      if (abortSignal.aborted) {
+        throw error;
+      }
+
+      // Avoid double reporting for the empty response case handled above
+      if (
+        error instanceof Error &&
+        error.message === 'API returned an empty response for generateJson.'
+      ) {
+        throw error;
+      }
+
+      await reportError(
+        error,
+        'Error generating JSON content via API.',
+        contents,
+        'generateJson-api',
+      );
+      throw new Error(
+        `Failed to generate JSON content: ${getErrorMessage(error)}`,
+      );
+    }
+  }
+
+  async generateContent(
+    contents: Content[],
+    generationConfig: GenerateContentConfig,
+    abortSignal: AbortSignal,
+    model?: string,
+  ): Promise<GenerateContentResponse> {
+    const modelToUse = model ?? this.config.getModel();
+    const configToUse: GenerateContentConfig = {
+      ...this.generateContentConfig,
+      ...generationConfig,
+    };
+
+    try {
+      const userMemory = this.config.getUserMemory();
+      const systemInstruction = getCoreSystemPrompt(userMemory);
+
+      const requestConfig: GenerateContentConfig = {
+        abortSignal,
+        ...configToUse,
+        systemInstruction,
+      };
+
+      const apiCall = () =>
+        this.getContentGenerator().generateContent(
+          {
+            model: modelToUse,
+            config: requestConfig,
+            contents,
+          },
+          this.lastPromptId,
+        );
+
+      const result = await retryWithBackoff(apiCall, {
+        onPersistent429: async (authType?: string, error?: unknown) =>
+          await this.handleFlashFallback(authType, error),
+        authType: this.config.getContentGeneratorConfig()?.authType,
+      });
+      return result;
+    } catch (error: unknown) {
+      if (abortSignal.aborted) {
+        throw error;
+      }
+
+      await reportError(
+        error,
+        `Error generating content via API with model ${modelToUse}.`,
+        {
+          requestContents: contents,
+          requestConfig: configToUse,
+        },
+        'generateContent-api',
+      );
+      throw new Error(
+        `Failed to generate content with model ${modelToUse}: ${getErrorMessage(error)}`,
+      );
+    }
+  }
+
+  async generateEmbedding(texts: string[]): Promise<number[][]> {
+    if (!texts || texts.length === 0) {
+      return [];
+    }
+    const embedModelParams: EmbedContentParameters = {
+      model: this.embeddingModel,
+      contents: texts,
+    };
+
+    const embedContentResponse =
+      await this.getContentGenerator().embedContent(embedModelParams);
+    if (
+      !embedContentResponse.embeddings ||
+      embedContentResponse.embeddings.length === 0
+    ) {
+      throw new Error('No embeddings found in API response.');
+    }
+
+    if (embedContentResponse.embeddings.length !== texts.length) {
+      throw new Error(
+        `API returned a mismatched number of embeddings. Expected ${texts.length}, got ${embedContentResponse.embeddings.length}.`,
+      );
+    }
+
+    return embedContentResponse.embeddings.map((embedding, index) => {
+      const values = embedding.values;
+      if (!values || values.length === 0) {
+        throw new Error(
+          `API returned an empty embedding for input text at index ${index}: "${texts[index]}"`,
+        );
+      }
+      return values;
+    });
+  }
+
+  async tryCompressChat(
+    prompt_id: string,
+    force: boolean = false,
+  ): Promise<ChatCompressionInfo | null> {
+    const curatedHistory = this.getChat().getHistory(true);
+
+    // Regardless of `force`, don't do anything if the history is empty.
+    if (curatedHistory.length === 0) {
+      return null;
+    }
+
+    const model = this.config.getModel();
+
+    const { totalTokens: originalTokenCount } =
+      await this.getContentGenerator().countTokens({
+        model,
+        contents: curatedHistory,
+      });
+    if (originalTokenCount === undefined) {
+      console.warn(`Could not determine token count for model ${model}.`);
+      return null;
+    }
+
+    const contextPercentageThreshold =
+      this.config.getChatCompression()?.contextPercentageThreshold;
+
+    // Don't compress if not forced and we are under the limit.
+    if (!force) {
+      const threshold =
+        contextPercentageThreshold ?? COMPRESSION_TOKEN_THRESHOLD;
+      if (originalTokenCount < threshold * tokenLimit(model)) {
+        return null;
+      }
+    }
+
+    let compressBeforeIndex = findIndexAfterFraction(
+      curatedHistory,
+      1 - COMPRESSION_PRESERVE_THRESHOLD,
+    );
+    // Find the first user message after the index. This is the start of the next turn.
+    while (
+      compressBeforeIndex < curatedHistory.length &&
+      (curatedHistory[compressBeforeIndex]?.role === 'model' ||
+        isFunctionResponse(curatedHistory[compressBeforeIndex]))
+    ) {
+      compressBeforeIndex++;
+    }
+
+    const historyToCompress = curatedHistory.slice(0, compressBeforeIndex);
+    const historyToKeep = curatedHistory.slice(compressBeforeIndex);
+
+    this.getChat().setHistory(historyToCompress);
+
+    const { text: summary } = await this.getChat().sendMessage(
+      {
+        message: {
+          text: 'First, reason in your scratchpad. Then, generate the <state_snapshot>.',
+        },
+        config: {
+          systemInstruction: { text: getCompressionPrompt() },
+        },
+      },
+      prompt_id,
+    );
+    this.chat = await this.startChat([
+      {
+        role: 'user',
+        parts: [{ text: summary }],
+      },
+      {
+        role: 'model',
+        parts: [{ text: 'Got it. Thanks for the additional context!' }],
+      },
+      ...historyToKeep,
+    ]);
+    this.forceFullIdeContext = true;
+
+    const { totalTokens: newTokenCount } =
+      await this.getContentGenerator().countTokens({
+        // model might change after calling `sendMessage`, so we get the newest value from config
+        model: this.config.getModel(),
+        contents: this.getChat().getHistory(),
+      });
+    if (newTokenCount === undefined) {
+      console.warn('Could not determine compressed history token count.');
+      return null;
+    }
+
+    logChatCompression(
+      this.config,
+      makeChatCompressionEvent({
+        tokens_before: originalTokenCount,
+        tokens_after: newTokenCount,
+      }),
+    );
+
+    return {
+      originalTokenCount,
+      newTokenCount,
+    };
+  }
+
+  /**
+   * Handles falling back to Flash model when persistent 429 errors occur for OAuth users.
+   * Uses a fallback handler if provided by the config; otherwise, returns null.
+   */
+  private async handleFlashFallback(
+    authType?: string,
+    error?: unknown,
+  ): Promise<string | null> {
+    // Handle different auth types
+    if (authType === AuthType.QWEN_OAUTH) {
+      return this.handleQwenOAuthError(error);
+    }
+
+    // Only handle fallback for OAuth users
+    if (authType !== AuthType.LOGIN_WITH_GOOGLE) {
+      return null;
+    }
+
+    const currentModel = this.config.getModel();
+    const fallbackModel = DEFAULT_GEMINI_FLASH_MODEL;
+
+    // Don't fallback if already using Flash model
+    if (currentModel === fallbackModel) {
+      return null;
+    }
+
+    // Check if config has a fallback handler (set by CLI package)
+    const fallbackHandler = this.config.flashFallbackHandler;
+    if (typeof fallbackHandler === 'function') {
+      try {
+        const accepted = await fallbackHandler(
+          currentModel,
+          fallbackModel,
+          error,
+        );
+        if (accepted !== false && accepted !== null) {
+          this.config.setModel(fallbackModel);
+          this.config.setFallbackMode(true);
+          return fallbackModel;
+        }
+        // Check if the model was switched manually in the handler
+        if (this.config.getModel() === fallbackModel) {
+          return null; // Model was switched but don't continue with current prompt
+        }
+      } catch (error) {
+        console.warn('Flash fallback handler failed:', error);
+      }
+    }
+
+    return null;
+  }
+
+  /**
+   * Handles Qwen OAuth authentication errors and rate limiting
+   */
+  private async handleQwenOAuthError(error?: unknown): Promise<string | null> {
+    if (!error) {
+      return null;
+    }
+
+    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;
+
+    // Check if this is an authentication/authorization error
+    const isAuthError =
+      errorCode === 401 ||
+      errorCode === 403 ||
+      errorMessage.includes('unauthorized') ||
+      errorMessage.includes('forbidden') ||
+      errorMessage.includes('invalid api key') ||
+      errorMessage.includes('authentication') ||
+      errorMessage.includes('access denied') ||
+      (errorMessage.includes('token') && errorMessage.includes('expired'));
+
+    // Check if this is a rate limiting error
+    const isRateLimitError =
+      errorCode === 429 ||
+      errorMessage.includes('429') ||
+      errorMessage.includes('rate limit') ||
+      errorMessage.includes('too many requests');
+
+    if (isAuthError) {
+      console.warn('Qwen OAuth authentication error detected:', errorMessage);
+      // The QwenContentGenerator should automatically handle token refresh
+      // If it still fails, it likely means the refresh token is also expired
+      console.log(
+        'Note: If this persists, you may need to re-authenticate with Qwen OAuth',
+      );
+      return null;
+    }
+
+    if (isRateLimitError) {
+      console.warn('Qwen API rate limit encountered:', errorMessage);
+      // For rate limiting, we don't need to do anything special
+      // The retry mechanism will handle the backoff
+      return null;
+    }
+
+    // For other errors, don't handle them specially
+    return null;
+  }
+}
+
+export const TEST_ONLY = {
+  COMPRESSION_PRESERVE_THRESHOLD,
+  COMPRESSION_TOKEN_THRESHOLD,
+};

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

@@ -0,0 +1,190 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import {
+  createContentGenerator,
+  AuthType,
+  createContentGeneratorConfig,
+  ContentGenerator,
+} from './contentGenerator.js';
+import { createCodeAssistContentGenerator } from '../code_assist/codeAssist.js';
+import { GoogleGenAI } from '@google/genai';
+import { Config } from '../config/config.js';
+import { LoggingContentGenerator } from './loggingContentGenerator.js';
+
+vi.mock('../code_assist/codeAssist.js');
+vi.mock('@google/genai');
+
+const mockConfig = {
+  getCliVersion: vi.fn().mockReturnValue('1.0.0'),
+} as unknown as Config;
+
+describe('createContentGenerator', () => {
+  it('should create a CodeAssistContentGenerator', async () => {
+    const mockGenerator = {} as unknown as ContentGenerator;
+    vi.mocked(createCodeAssistContentGenerator).mockResolvedValue(
+      mockGenerator as never,
+    );
+    const generator = await createContentGenerator(
+      {
+        model: 'test-model',
+        authType: AuthType.LOGIN_WITH_GOOGLE,
+      },
+      mockConfig,
+    );
+    expect(createCodeAssistContentGenerator).toHaveBeenCalled();
+    expect(generator).toEqual(
+      new LoggingContentGenerator(mockGenerator, mockConfig),
+    );
+  });
+
+  it('should create a GoogleGenAI content generator', async () => {
+    const mockConfig = {
+      getUsageStatisticsEnabled: () => true,
+    } as unknown as Config;
+
+    const mockGenerator = {
+      models: {},
+    } as unknown as GoogleGenAI;
+    vi.mocked(GoogleGenAI).mockImplementation(() => mockGenerator as never);
+    const generator = await createContentGenerator(
+      {
+        model: 'test-model',
+        apiKey: 'test-api-key',
+        authType: AuthType.USE_GEMINI,
+      },
+      mockConfig,
+    );
+    expect(GoogleGenAI).toHaveBeenCalledWith({
+      apiKey: 'test-api-key',
+      vertexai: undefined,
+      httpOptions: {
+        headers: {
+          'User-Agent': expect.any(String),
+          'x-gemini-api-privileged-user-id': expect.any(String),
+        },
+      },
+    });
+    expect(generator).toEqual(
+      new LoggingContentGenerator(
+        (mockGenerator as GoogleGenAI).models,
+        mockConfig,
+      ),
+    );
+  });
+
+  it('should create a GoogleGenAI content generator with client install id logging disabled', async () => {
+    const mockConfig = {
+      getUsageStatisticsEnabled: () => false,
+    } as unknown as Config;
+    const mockGenerator = {
+      models: {},
+    } as unknown as GoogleGenAI;
+    vi.mocked(GoogleGenAI).mockImplementation(() => mockGenerator as never);
+    const generator = await createContentGenerator(
+      {
+        model: 'test-model',
+        apiKey: 'test-api-key',
+        authType: AuthType.USE_GEMINI,
+      },
+      mockConfig,
+    );
+    expect(GoogleGenAI).toHaveBeenCalledWith({
+      apiKey: 'test-api-key',
+      vertexai: undefined,
+      httpOptions: {
+        headers: {
+          'User-Agent': expect.any(String),
+        },
+      },
+    });
+    expect(generator).toEqual(
+      new LoggingContentGenerator(
+        (mockGenerator as GoogleGenAI).models,
+        mockConfig,
+      ),
+    );
+  });
+});
+
+describe('createContentGeneratorConfig', () => {
+  const mockConfig = {
+    getModel: vi.fn().mockReturnValue('gemini-pro'),
+    setModel: vi.fn(),
+    flashFallbackHandler: vi.fn(),
+    getProxy: vi.fn(),
+    getEnableOpenAILogging: vi.fn().mockReturnValue(false),
+    getSamplingParams: vi.fn().mockReturnValue(undefined),
+    getContentGeneratorTimeout: vi.fn().mockReturnValue(undefined),
+    getContentGeneratorMaxRetries: vi.fn().mockReturnValue(undefined),
+    getContentGeneratorSamplingParams: vi.fn().mockReturnValue(undefined),
+    getCliVersion: vi.fn().mockReturnValue('1.0.0'),
+  } as unknown as Config;
+
+  beforeEach(() => {
+    // Reset modules to re-evaluate imports and environment variables
+    vi.resetModules();
+    vi.clearAllMocks();
+  });
+
+  afterEach(() => {
+    vi.unstubAllEnvs();
+  });
+
+  it('should configure for Gemini using GEMINI_API_KEY when set', async () => {
+    vi.stubEnv('GEMINI_API_KEY', 'env-gemini-key');
+    const config = await createContentGeneratorConfig(
+      mockConfig,
+      AuthType.USE_GEMINI,
+    );
+    expect(config.apiKey).toBe('env-gemini-key');
+    expect(config.vertexai).toBe(false);
+  });
+
+  it('should not configure for Gemini if GEMINI_API_KEY is empty', async () => {
+    vi.stubEnv('GEMINI_API_KEY', '');
+    const config = await createContentGeneratorConfig(
+      mockConfig,
+      AuthType.USE_GEMINI,
+    );
+    expect(config.apiKey).toBeUndefined();
+    expect(config.vertexai).toBeUndefined();
+  });
+
+  it('should configure for Vertex AI using GOOGLE_API_KEY when set', async () => {
+    vi.stubEnv('GOOGLE_API_KEY', 'env-google-key');
+    const config = await createContentGeneratorConfig(
+      mockConfig,
+      AuthType.USE_VERTEX_AI,
+    );
+    expect(config.apiKey).toBe('env-google-key');
+    expect(config.vertexai).toBe(true);
+  });
+
+  it('should configure for Vertex AI using GCP project and location when set', async () => {
+    vi.stubEnv('GOOGLE_CLOUD_PROJECT', 'env-gcp-project');
+    vi.stubEnv('GOOGLE_CLOUD_LOCATION', 'env-gcp-location');
+    const config = await createContentGeneratorConfig(
+      mockConfig,
+      AuthType.USE_VERTEX_AI,
+    );
+    expect(config.vertexai).toBe(true);
+    expect(config.apiKey).toBeUndefined();
+  });
+
+  it('should not configure for Vertex AI if required env vars are empty', async () => {
+    vi.stubEnv('GOOGLE_API_KEY', '');
+    vi.stubEnv('GOOGLE_CLOUD_PROJECT', '');
+    vi.stubEnv('GOOGLE_CLOUD_LOCATION', '');
+    const config = await createContentGeneratorConfig(
+      mockConfig,
+      AuthType.USE_VERTEX_AI,
+    );
+    expect(config.apiKey).toBeUndefined();
+    expect(config.vertexai).toBeUndefined();
+  });
+});

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

@@ -0,0 +1,245 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import {
+  CountTokensResponse,
+  GenerateContentResponse,
+  GenerateContentParameters,
+  CountTokensParameters,
+  EmbedContentResponse,
+  EmbedContentParameters,
+  GoogleGenAI,
+} from '@google/genai';
+import { createCodeAssistContentGenerator } from '../code_assist/codeAssist.js';
+import { DEFAULT_GEMINI_MODEL, DEFAULT_QWEN_MODEL } from '../config/models.js';
+import { Config } from '../config/config.js';
+
+import { UserTierId } from '../code_assist/types.js';
+import { LoggingContentGenerator } from './loggingContentGenerator.js';
+import { getInstallationId } from '../utils/user_id.js';
+
+/**
+ * Interface abstracting the core functionalities for generating content and counting tokens.
+ */
+export interface ContentGenerator {
+  generateContent(
+    request: GenerateContentParameters,
+    userPromptId: string,
+  ): Promise<GenerateContentResponse>;
+
+  generateContentStream(
+    request: GenerateContentParameters,
+    userPromptId: string,
+  ): Promise<AsyncGenerator<GenerateContentResponse>>;
+
+  countTokens(request: CountTokensParameters): Promise<CountTokensResponse>;
+
+  embedContent(request: EmbedContentParameters): Promise<EmbedContentResponse>;
+
+  userTier?: UserTierId;
+}
+
+export enum AuthType {
+  LOGIN_WITH_GOOGLE = 'oauth-personal',
+  USE_GEMINI = 'gemini-api-key',
+  USE_VERTEX_AI = 'vertex-ai',
+  CLOUD_SHELL = 'cloud-shell',
+  USE_OPENAI = 'openai',
+  QWEN_OAUTH = 'qwen-oauth',
+}
+
+export type ContentGeneratorConfig = {
+  model: string;
+  apiKey?: string;
+  baseUrl?: string;
+  vertexai?: boolean;
+  authType?: AuthType | undefined;
+  enableOpenAILogging?: boolean;
+  // Timeout configuration in milliseconds
+  timeout?: number;
+  // Maximum retries for failed requests
+  maxRetries?: number;
+  samplingParams?: {
+    top_p?: number;
+    top_k?: number;
+    repetition_penalty?: number;
+    presence_penalty?: number;
+    frequency_penalty?: number;
+    temperature?: number;
+    max_tokens?: number;
+  };
+  proxy?: string | undefined;
+  userAgent?: string;
+};
+
+export function createContentGeneratorConfig(
+  config: Config,
+  authType: AuthType | undefined,
+): ContentGeneratorConfig {
+  const geminiApiKey = process.env['GEMINI_API_KEY'] || undefined;
+  const googleApiKey = process.env['GOOGLE_API_KEY'] || undefined;
+  const googleCloudProject = process.env['GOOGLE_CLOUD_PROJECT'] || undefined;
+  const googleCloudLocation = process.env['GOOGLE_CLOUD_LOCATION'] || undefined;
+
+  // openai auth
+  const openaiApiKey = process.env['OPENAI_API_KEY'] || undefined;
+  const openaiBaseUrl = process.env['OPENAI_BASE_URL'] || undefined;
+  const openaiModel = process.env['OPENAI_MODEL'] || undefined;
+
+  // Use runtime model from config if available; otherwise, fall back to parameter or default
+  const effectiveModel = config.getModel() || DEFAULT_GEMINI_MODEL;
+
+  const contentGeneratorConfig: ContentGeneratorConfig = {
+    model: effectiveModel,
+    authType,
+    proxy: config?.getProxy(),
+    enableOpenAILogging: config.getEnableOpenAILogging(),
+    timeout: config.getContentGeneratorTimeout(),
+    maxRetries: config.getContentGeneratorMaxRetries(),
+    samplingParams: config.getContentGeneratorSamplingParams(),
+  };
+
+  // If we are using Google auth or we are in Cloud Shell, there is nothing else to validate for now
+  if (
+    authType === AuthType.LOGIN_WITH_GOOGLE ||
+    authType === AuthType.CLOUD_SHELL
+  ) {
+    return contentGeneratorConfig;
+  }
+
+  if (authType === AuthType.USE_GEMINI && geminiApiKey) {
+    contentGeneratorConfig.apiKey = geminiApiKey;
+    contentGeneratorConfig.vertexai = false;
+
+    return contentGeneratorConfig;
+  }
+
+  if (
+    authType === AuthType.USE_VERTEX_AI &&
+    (googleApiKey || (googleCloudProject && googleCloudLocation))
+  ) {
+    contentGeneratorConfig.apiKey = googleApiKey;
+    contentGeneratorConfig.vertexai = true;
+
+    return contentGeneratorConfig;
+  }
+
+  if (authType === AuthType.USE_OPENAI && openaiApiKey) {
+    contentGeneratorConfig.apiKey = openaiApiKey;
+    contentGeneratorConfig.baseUrl = openaiBaseUrl;
+    contentGeneratorConfig.model = openaiModel || DEFAULT_QWEN_MODEL;
+
+    return contentGeneratorConfig;
+  }
+
+  if (authType === AuthType.QWEN_OAUTH) {
+    // For Qwen OAuth, we'll handle the API key dynamically in createContentGenerator
+    // Set a special marker to indicate this is Qwen OAuth
+    contentGeneratorConfig.apiKey = 'QWEN_OAUTH_DYNAMIC_TOKEN';
+
+    // Prefer to use qwen3-coder-plus as the default Qwen model if QWEN_MODEL is not set.
+    contentGeneratorConfig.model =
+      process.env['QWEN_MODEL'] || DEFAULT_QWEN_MODEL;
+
+    return contentGeneratorConfig;
+  }
+
+  return contentGeneratorConfig;
+}
+
+export async function createContentGenerator(
+  config: ContentGeneratorConfig,
+  gcConfig: Config,
+  sessionId?: string,
+): Promise<ContentGenerator> {
+  const version = process.env['CLI_VERSION'] || process.version;
+  const userAgent = `QwenCode/${version} (${process.platform}; ${process.arch})`;
+  const baseHeaders: Record<string, string> = {
+    'User-Agent': userAgent,
+  };
+
+  if (
+    config.authType === AuthType.LOGIN_WITH_GOOGLE ||
+    config.authType === AuthType.CLOUD_SHELL
+  ) {
+    const httpOptions = { headers: baseHeaders };
+    return new LoggingContentGenerator(
+      await createCodeAssistContentGenerator(
+        httpOptions,
+        config.authType,
+        gcConfig,
+        sessionId,
+      ),
+      gcConfig,
+    );
+  }
+
+  if (
+    config.authType === AuthType.USE_GEMINI ||
+    config.authType === AuthType.USE_VERTEX_AI
+  ) {
+    let headers: Record<string, string> = { ...baseHeaders };
+    if (gcConfig?.getUsageStatisticsEnabled()) {
+      const installationId = getInstallationId();
+      headers = {
+        ...headers,
+        'x-gemini-api-privileged-user-id': `${installationId}`,
+      };
+    }
+    const httpOptions = { headers };
+
+    const googleGenAI = new GoogleGenAI({
+      apiKey: config.apiKey === '' ? undefined : config.apiKey,
+      vertexai: config.vertexai,
+      httpOptions,
+    });
+    return new LoggingContentGenerator(googleGenAI.models, gcConfig);
+  }
+
+  if (config.authType === AuthType.USE_OPENAI) {
+    if (!config.apiKey) {
+      throw new Error('OpenAI API key is required');
+    }
+
+    // Import OpenAIContentGenerator dynamically to avoid circular dependencies
+    const { OpenAIContentGenerator } = await import(
+      './openaiContentGenerator.js'
+    );
+
+    // Always use OpenAIContentGenerator, logging is controlled by enableOpenAILogging flag
+    return new OpenAIContentGenerator(config, gcConfig);
+  }
+
+  if (config.authType === AuthType.QWEN_OAUTH) {
+    if (config.apiKey !== 'QWEN_OAUTH_DYNAMIC_TOKEN') {
+      throw new Error('Invalid Qwen OAuth configuration');
+    }
+
+    // Import required classes dynamically
+    const { getQwenOAuthClient: getQwenOauthClient } = await import(
+      '../qwen/qwenOAuth2.js'
+    );
+    const { QwenContentGenerator } = await import(
+      '../qwen/qwenContentGenerator.js'
+    );
+
+    try {
+      // Get the Qwen OAuth client (now includes integrated token management)
+      const qwenClient = await getQwenOauthClient(gcConfig);
+
+      // Create the content generator with dynamic token management
+      return new QwenContentGenerator(qwenClient, config, gcConfig);
+    } catch (error) {
+      throw new Error(
+        `Failed to initialize Qwen: ${error instanceof Error ? error.message : String(error)}`,
+      );
+    }
+  }
+
+  throw new Error(
+    `Error creating contentGenerator: Unsupported authType: ${config.authType}`,
+  );
+}

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

@@ -0,0 +1,961 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { describe, it, expect, vi } from 'vitest';
+import {
+  CoreToolScheduler,
+  ToolCall,
+  WaitingToolCall,
+  convertToFunctionResponse,
+} from './coreToolScheduler.js';
+import {
+  BaseDeclarativeTool,
+  BaseToolInvocation,
+  ToolCallConfirmationDetails,
+  ToolConfirmationOutcome,
+  ToolConfirmationPayload,
+  ToolInvocation,
+  ToolResult,
+  Config,
+  Kind,
+  ApprovalMode,
+  ToolRegistry,
+} from '../index.js';
+import { Part, PartListUnion } from '@google/genai';
+import { MockModifiableTool, MockTool } from '../test-utils/tools.js';
+
+class TestApprovalTool extends BaseDeclarativeTool<{ id: string }, ToolResult> {
+  static readonly Name = 'testApprovalTool';
+
+  constructor(private config: Config) {
+    super(
+      TestApprovalTool.Name,
+      'TestApprovalTool',
+      'A tool for testing approval logic',
+      Kind.Edit,
+      {
+        properties: { id: { type: 'string' } },
+        required: ['id'],
+        type: 'object',
+      },
+    );
+  }
+
+  protected createInvocation(params: {
+    id: string;
+  }): ToolInvocation<{ id: string }, ToolResult> {
+    return new TestApprovalInvocation(this.config, params);
+  }
+}
+
+class TestApprovalInvocation extends BaseToolInvocation<
+  { id: string },
+  ToolResult
+> {
+  constructor(
+    private config: Config,
+    params: { id: string },
+  ) {
+    super(params);
+  }
+
+  getDescription(): string {
+    return `Test tool ${this.params.id}`;
+  }
+
+  override async shouldConfirmExecute(): Promise<
+    ToolCallConfirmationDetails | false
+  > {
+    // Need confirmation unless approval mode is AUTO_EDIT
+    if (this.config.getApprovalMode() === ApprovalMode.AUTO_EDIT) {
+      return false;
+    }
+
+    return {
+      type: 'edit',
+      title: `Confirm Test Tool ${this.params.id}`,
+      fileName: `test-${this.params.id}.txt`,
+      filePath: `/test-${this.params.id}.txt`,
+      fileDiff: 'Test diff content',
+      originalContent: '',
+      newContent: 'Test content',
+      onConfirm: async (outcome: ToolConfirmationOutcome) => {
+        if (outcome === ToolConfirmationOutcome.ProceedAlways) {
+          this.config.setApprovalMode(ApprovalMode.AUTO_EDIT);
+        }
+      },
+    };
+  }
+
+  async execute(): Promise<ToolResult> {
+    return {
+      llmContent: `Executed test tool ${this.params.id}`,
+      returnDisplay: `Executed test tool ${this.params.id}`,
+    };
+  }
+}
+
+describe('CoreToolScheduler', () => {
+  it('should cancel a tool call if the signal is aborted before confirmation', async () => {
+    const mockTool = new MockTool();
+    mockTool.shouldConfirm = true;
+    const declarativeTool = mockTool;
+    const mockToolRegistry = {
+      getTool: () => declarativeTool,
+      getFunctionDeclarations: () => [],
+      tools: new Map(),
+      discovery: {},
+      registerTool: () => {},
+      getToolByName: () => declarativeTool,
+      getToolByDisplayName: () => declarativeTool,
+      getTools: () => [],
+      discoverTools: async () => {},
+      getAllTools: () => [],
+      getToolsByServer: () => [],
+    } as unknown as ToolRegistry;
+
+    const onAllToolCallsComplete = vi.fn();
+    const onToolCallsUpdate = vi.fn();
+
+    const mockConfig = {
+      getSessionId: () => 'test-session-id',
+      getUsageStatisticsEnabled: () => true,
+      getDebugMode: () => false,
+      getApprovalMode: () => ApprovalMode.DEFAULT,
+      getContentGeneratorConfig: () => ({
+        model: 'test-model',
+        authType: 'oauth-personal',
+      }),
+    } as unknown as Config;
+
+    const scheduler = new CoreToolScheduler({
+      config: mockConfig,
+      toolRegistry: mockToolRegistry,
+      onAllToolCallsComplete,
+      onToolCallsUpdate,
+      getPreferredEditor: () => 'vscode',
+      onEditorClose: vi.fn(),
+    });
+
+    const abortController = new AbortController();
+    const request = {
+      callId: '1',
+      name: 'mockTool',
+      args: {},
+      isClientInitiated: false,
+      prompt_id: 'prompt-id-1',
+    };
+
+    abortController.abort();
+    await scheduler.schedule([request], abortController.signal);
+
+    expect(onAllToolCallsComplete).toHaveBeenCalled();
+    const completedCalls = onAllToolCallsComplete.mock
+      .calls[0][0] as ToolCall[];
+    expect(completedCalls[0].status).toBe('cancelled');
+  });
+});
+
+describe('CoreToolScheduler with payload', () => {
+  it('should update args and diff and execute tool when payload is provided', async () => {
+    const mockTool = new MockModifiableTool();
+    const declarativeTool = mockTool;
+    const mockToolRegistry = {
+      getTool: () => declarativeTool,
+      getFunctionDeclarations: () => [],
+      tools: new Map(),
+      discovery: {},
+      registerTool: () => {},
+      getToolByName: () => declarativeTool,
+      getToolByDisplayName: () => declarativeTool,
+      getTools: () => [],
+      discoverTools: async () => {},
+      getAllTools: () => [],
+      getToolsByServer: () => [],
+    } as unknown as ToolRegistry;
+
+    const onAllToolCallsComplete = vi.fn();
+    const onToolCallsUpdate = vi.fn();
+
+    const mockConfig = {
+      getSessionId: () => 'test-session-id',
+      getUsageStatisticsEnabled: () => true,
+      getDebugMode: () => false,
+      getApprovalMode: () => ApprovalMode.DEFAULT,
+      getContentGeneratorConfig: () => ({
+        model: 'test-model',
+        authType: 'oauth-personal',
+      }),
+    } as unknown as Config;
+
+    const scheduler = new CoreToolScheduler({
+      config: mockConfig,
+      toolRegistry: mockToolRegistry,
+      onAllToolCallsComplete,
+      onToolCallsUpdate,
+      getPreferredEditor: () => 'vscode',
+      onEditorClose: vi.fn(),
+    });
+
+    const abortController = new AbortController();
+    const request = {
+      callId: '1',
+      name: 'mockModifiableTool',
+      args: {},
+      isClientInitiated: false,
+      prompt_id: 'prompt-id-2',
+    };
+
+    await scheduler.schedule([request], abortController.signal);
+
+    await vi.waitFor(() => {
+      const awaitingCall = onToolCallsUpdate.mock.calls.find(
+        (call) => call[0][0].status === 'awaiting_approval',
+      )?.[0][0];
+      expect(awaitingCall).toBeDefined();
+    });
+
+    const awaitingCall = onToolCallsUpdate.mock.calls.find(
+      (call) => call[0][0].status === 'awaiting_approval',
+    )?.[0][0];
+    const confirmationDetails = awaitingCall.confirmationDetails;
+
+    if (confirmationDetails) {
+      const payload: ToolConfirmationPayload = { newContent: 'final version' };
+      await confirmationDetails.onConfirm(
+        ToolConfirmationOutcome.ProceedOnce,
+        payload,
+      );
+    }
+
+    expect(onAllToolCallsComplete).toHaveBeenCalled();
+    const completedCalls = onAllToolCallsComplete.mock
+      .calls[0][0] as ToolCall[];
+    expect(completedCalls[0].status).toBe('success');
+    expect(mockTool.executeFn).toHaveBeenCalledWith({
+      newContent: 'final version',
+    });
+  });
+});
+
+describe('convertToFunctionResponse', () => {
+  const toolName = 'testTool';
+  const callId = 'call1';
+
+  it('should handle simple string llmContent', () => {
+    const llmContent = 'Simple text output';
+    const result = convertToFunctionResponse(toolName, callId, llmContent);
+    expect(result).toEqual({
+      functionResponse: {
+        name: toolName,
+        id: callId,
+        response: { output: 'Simple text output' },
+      },
+    });
+  });
+
+  it('should handle llmContent as a single Part with text', () => {
+    const llmContent: Part = { text: 'Text from Part object' };
+    const result = convertToFunctionResponse(toolName, callId, llmContent);
+    expect(result).toEqual({
+      functionResponse: {
+        name: toolName,
+        id: callId,
+        response: { output: 'Text from Part object' },
+      },
+    });
+  });
+
+  it('should handle llmContent as a PartListUnion array with a single text Part', () => {
+    const llmContent: PartListUnion = [{ text: 'Text from array' }];
+    const result = convertToFunctionResponse(toolName, callId, llmContent);
+    expect(result).toEqual({
+      functionResponse: {
+        name: toolName,
+        id: callId,
+        response: { output: 'Text from array' },
+      },
+    });
+  });
+
+  it('should handle llmContent with inlineData', () => {
+    const llmContent: Part = {
+      inlineData: { mimeType: 'image/png', data: 'base64...' },
+    };
+    const result = convertToFunctionResponse(toolName, callId, llmContent);
+    expect(result).toEqual([
+      {
+        functionResponse: {
+          name: toolName,
+          id: callId,
+          response: {
+            output: 'Binary content of type image/png was processed.',
+          },
+        },
+      },
+      llmContent,
+    ]);
+  });
+
+  it('should handle llmContent with fileData', () => {
+    const llmContent: Part = {
+      fileData: { mimeType: 'application/pdf', fileUri: 'gs://...' },
+    };
+    const result = convertToFunctionResponse(toolName, callId, llmContent);
+    expect(result).toEqual([
+      {
+        functionResponse: {
+          name: toolName,
+          id: callId,
+          response: {
+            output: 'Binary content of type application/pdf was processed.',
+          },
+        },
+      },
+      llmContent,
+    ]);
+  });
+
+  it('should handle llmContent as an array of multiple Parts (text and inlineData)', () => {
+    const llmContent: PartListUnion = [
+      { text: 'Some textual description' },
+      { inlineData: { mimeType: 'image/jpeg', data: 'base64data...' } },
+      { text: 'Another text part' },
+    ];
+    const result = convertToFunctionResponse(toolName, callId, llmContent);
+    expect(result).toEqual([
+      {
+        functionResponse: {
+          name: toolName,
+          id: callId,
+          response: { output: 'Tool execution succeeded.' },
+        },
+      },
+      ...llmContent,
+    ]);
+  });
+
+  it('should handle llmContent as an array with a single inlineData Part', () => {
+    const llmContent: PartListUnion = [
+      { inlineData: { mimeType: 'image/gif', data: 'gifdata...' } },
+    ];
+    const result = convertToFunctionResponse(toolName, callId, llmContent);
+    expect(result).toEqual([
+      {
+        functionResponse: {
+          name: toolName,
+          id: callId,
+          response: {
+            output: 'Binary content of type image/gif was processed.',
+          },
+        },
+      },
+      ...llmContent,
+    ]);
+  });
+
+  it('should handle llmContent as a generic Part (not text, inlineData, or fileData)', () => {
+    const llmContent: Part = { functionCall: { name: 'test', args: {} } };
+    const result = convertToFunctionResponse(toolName, callId, llmContent);
+    expect(result).toEqual({
+      functionResponse: {
+        name: toolName,
+        id: callId,
+        response: { output: 'Tool execution succeeded.' },
+      },
+    });
+  });
+
+  it('should handle empty string llmContent', () => {
+    const llmContent = '';
+    const result = convertToFunctionResponse(toolName, callId, llmContent);
+    expect(result).toEqual({
+      functionResponse: {
+        name: toolName,
+        id: callId,
+        response: { output: '' },
+      },
+    });
+  });
+
+  it('should handle llmContent as an empty array', () => {
+    const llmContent: PartListUnion = [];
+    const result = convertToFunctionResponse(toolName, callId, llmContent);
+    expect(result).toEqual([
+      {
+        functionResponse: {
+          name: toolName,
+          id: callId,
+          response: { output: 'Tool execution succeeded.' },
+        },
+      },
+    ]);
+  });
+
+  it('should handle llmContent as a Part with undefined inlineData/fileData/text', () => {
+    const llmContent: Part = {}; // An empty part object
+    const result = convertToFunctionResponse(toolName, callId, llmContent);
+    expect(result).toEqual({
+      functionResponse: {
+        name: toolName,
+        id: callId,
+        response: { output: 'Tool execution succeeded.' },
+      },
+    });
+  });
+});
+
+class MockEditToolInvocation extends BaseToolInvocation<
+  Record<string, unknown>,
+  ToolResult
+> {
+  constructor(params: Record<string, unknown>) {
+    super(params);
+  }
+
+  getDescription(): string {
+    return 'A mock edit tool invocation';
+  }
+
+  override async shouldConfirmExecute(
+    _abortSignal: AbortSignal,
+  ): Promise<ToolCallConfirmationDetails | false> {
+    return {
+      type: 'edit',
+      title: 'Confirm Edit',
+      fileName: 'test.txt',
+      filePath: 'test.txt',
+      fileDiff:
+        '--- test.txt\n+++ test.txt\n@@ -1,1 +1,1 @@\n-old content\n+new content',
+      originalContent: 'old content',
+      newContent: 'new content',
+      onConfirm: async () => {},
+    };
+  }
+
+  async execute(_abortSignal: AbortSignal): Promise<ToolResult> {
+    return {
+      llmContent: 'Edited successfully',
+      returnDisplay: 'Edited successfully',
+    };
+  }
+}
+
+class MockEditTool extends BaseDeclarativeTool<
+  Record<string, unknown>,
+  ToolResult
+> {
+  constructor() {
+    super('mockEditTool', 'mockEditTool', 'A mock edit tool', Kind.Edit, {});
+  }
+
+  protected createInvocation(
+    params: Record<string, unknown>,
+  ): ToolInvocation<Record<string, unknown>, ToolResult> {
+    return new MockEditToolInvocation(params);
+  }
+}
+
+describe('CoreToolScheduler edit cancellation', () => {
+  it('should preserve diff when an edit is cancelled', async () => {
+    const mockEditTool = new MockEditTool();
+    const declarativeTool = mockEditTool;
+    const mockToolRegistry = {
+      getTool: () => declarativeTool,
+      getFunctionDeclarations: () => [],
+      tools: new Map(),
+      discovery: {},
+      registerTool: () => {},
+      getToolByName: () => declarativeTool,
+      getToolByDisplayName: () => declarativeTool,
+      getTools: () => [],
+      discoverTools: async () => {},
+      getAllTools: () => [],
+      getToolsByServer: () => [],
+    } as unknown as ToolRegistry;
+
+    const onAllToolCallsComplete = vi.fn();
+    const onToolCallsUpdate = vi.fn();
+
+    const mockConfig = {
+      getSessionId: () => 'test-session-id',
+      getUsageStatisticsEnabled: () => true,
+      getDebugMode: () => false,
+      getApprovalMode: () => ApprovalMode.DEFAULT,
+      getContentGeneratorConfig: () => ({
+        model: 'test-model',
+        authType: 'oauth-personal',
+      }),
+    } as unknown as Config;
+
+    const scheduler = new CoreToolScheduler({
+      config: mockConfig,
+      toolRegistry: mockToolRegistry,
+      onAllToolCallsComplete,
+      onToolCallsUpdate,
+      getPreferredEditor: () => 'vscode',
+      onEditorClose: vi.fn(),
+    });
+
+    const abortController = new AbortController();
+    const request = {
+      callId: '1',
+      name: 'mockEditTool',
+      args: {},
+      isClientInitiated: false,
+      prompt_id: 'prompt-id-1',
+    };
+
+    await scheduler.schedule([request], abortController.signal);
+
+    // Wait for the tool to reach awaiting_approval state
+    const awaitingCall = onToolCallsUpdate.mock.calls.find(
+      (call) => call[0][0].status === 'awaiting_approval',
+    )?.[0][0];
+
+    expect(awaitingCall).toBeDefined();
+
+    // Cancel the edit
+    const confirmationDetails = awaitingCall.confirmationDetails;
+    if (confirmationDetails) {
+      await confirmationDetails.onConfirm(ToolConfirmationOutcome.Cancel);
+    }
+
+    expect(onAllToolCallsComplete).toHaveBeenCalled();
+    const completedCalls = onAllToolCallsComplete.mock
+      .calls[0][0] as ToolCall[];
+
+    expect(completedCalls[0].status).toBe('cancelled');
+
+    // Check that the diff is preserved
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const cancelledCall = completedCalls[0] as any;
+    expect(cancelledCall.response.resultDisplay).toBeDefined();
+    expect(cancelledCall.response.resultDisplay.fileDiff).toBe(
+      '--- test.txt\n+++ test.txt\n@@ -1,1 +1,1 @@\n-old content\n+new content',
+    );
+    expect(cancelledCall.response.resultDisplay.fileName).toBe('test.txt');
+  });
+});
+
+describe('CoreToolScheduler YOLO mode', () => {
+  it('should execute tool requiring confirmation directly without waiting', async () => {
+    // Arrange
+    const mockTool = new MockTool();
+    mockTool.executeFn.mockReturnValue({
+      llmContent: 'Tool executed',
+      returnDisplay: 'Tool executed',
+    });
+    // This tool would normally require confirmation.
+    mockTool.shouldConfirm = true;
+    const declarativeTool = mockTool;
+
+    const mockToolRegistry = {
+      getTool: () => declarativeTool,
+      getToolByName: () => declarativeTool,
+      // Other properties are not needed for this test but are included for type consistency.
+      getFunctionDeclarations: () => [],
+      tools: new Map(),
+      discovery: {},
+      registerTool: () => {},
+      getToolByDisplayName: () => declarativeTool,
+      getTools: () => [],
+      discoverTools: async () => {},
+      getAllTools: () => [],
+      getToolsByServer: () => [],
+    } as unknown as ToolRegistry;
+
+    const onAllToolCallsComplete = vi.fn();
+    const onToolCallsUpdate = vi.fn();
+
+    // Configure the scheduler for YOLO mode.
+    const mockConfig = {
+      getSessionId: () => 'test-session-id',
+      getUsageStatisticsEnabled: () => true,
+      getDebugMode: () => false,
+      getApprovalMode: () => ApprovalMode.YOLO,
+      getContentGeneratorConfig: () => ({
+        model: 'test-model',
+        authType: 'oauth-personal',
+      }),
+    } as unknown as Config;
+
+    const scheduler = new CoreToolScheduler({
+      config: mockConfig,
+      toolRegistry: mockToolRegistry,
+      onAllToolCallsComplete,
+      onToolCallsUpdate,
+      getPreferredEditor: () => 'vscode',
+      onEditorClose: vi.fn(),
+    });
+
+    const abortController = new AbortController();
+    const request = {
+      callId: '1',
+      name: 'mockTool',
+      args: { param: 'value' },
+      isClientInitiated: false,
+      prompt_id: 'prompt-id-yolo',
+    };
+
+    // Act
+    await scheduler.schedule([request], abortController.signal);
+
+    // Assert
+    // 1. The tool's execute method was called directly.
+    expect(mockTool.executeFn).toHaveBeenCalledWith({ param: 'value' });
+
+    // 2. The tool call status never entered 'awaiting_approval'.
+    const statusUpdates = onToolCallsUpdate.mock.calls
+      .map((call) => (call[0][0] as ToolCall)?.status)
+      .filter(Boolean);
+    expect(statusUpdates).not.toContain('awaiting_approval');
+    expect(statusUpdates).toEqual([
+      'validating',
+      'scheduled',
+      'executing',
+      'success',
+    ]);
+
+    // 3. The final callback indicates the tool call was successful.
+    expect(onAllToolCallsComplete).toHaveBeenCalled();
+    const completedCalls = onAllToolCallsComplete.mock
+      .calls[0][0] as ToolCall[];
+    expect(completedCalls).toHaveLength(1);
+    const completedCall = completedCalls[0];
+    expect(completedCall.status).toBe('success');
+    if (completedCall.status === 'success') {
+      expect(completedCall.response.resultDisplay).toBe('Tool executed');
+    }
+  });
+});
+
+describe('CoreToolScheduler request queueing', () => {
+  it('should queue a request if another is running', async () => {
+    let resolveFirstCall: (result: ToolResult) => void;
+    const firstCallPromise = new Promise<ToolResult>((resolve) => {
+      resolveFirstCall = resolve;
+    });
+
+    const mockTool = new MockTool();
+    mockTool.executeFn.mockImplementation(() => firstCallPromise);
+    const declarativeTool = mockTool;
+
+    const mockToolRegistry = {
+      getTool: () => declarativeTool,
+      getToolByName: () => declarativeTool,
+      getFunctionDeclarations: () => [],
+      tools: new Map(),
+      discovery: {},
+      registerTool: () => {},
+      getToolByDisplayName: () => declarativeTool,
+      getTools: () => [],
+      discoverTools: async () => {},
+      getAllTools: () => [],
+      getToolsByServer: () => [],
+    } as unknown as ToolRegistry;
+
+    const onAllToolCallsComplete = vi.fn();
+    const onToolCallsUpdate = vi.fn();
+
+    const mockConfig = {
+      getSessionId: () => 'test-session-id',
+      getUsageStatisticsEnabled: () => true,
+      getDebugMode: () => false,
+      getApprovalMode: () => ApprovalMode.YOLO, // Use YOLO to avoid confirmation prompts
+      getContentGeneratorConfig: () => ({
+        model: 'test-model',
+        authType: 'oauth-personal',
+      }),
+    } as unknown as Config;
+
+    const scheduler = new CoreToolScheduler({
+      config: mockConfig,
+      toolRegistry: mockToolRegistry,
+      onAllToolCallsComplete,
+      onToolCallsUpdate,
+      getPreferredEditor: () => 'vscode',
+      onEditorClose: vi.fn(),
+    });
+
+    const abortController = new AbortController();
+    const request1 = {
+      callId: '1',
+      name: 'mockTool',
+      args: { a: 1 },
+      isClientInitiated: false,
+      prompt_id: 'prompt-1',
+    };
+    const request2 = {
+      callId: '2',
+      name: 'mockTool',
+      args: { b: 2 },
+      isClientInitiated: false,
+      prompt_id: 'prompt-2',
+    };
+
+    // Schedule the first call, which will pause execution.
+    scheduler.schedule([request1], abortController.signal);
+
+    // Wait for the first call to be in the 'executing' state.
+    await vi.waitFor(() => {
+      const calls = onToolCallsUpdate.mock.calls.at(-1)?.[0] as ToolCall[];
+      expect(calls?.[0]?.status).toBe('executing');
+    });
+
+    // Schedule the second call while the first is "running".
+    const schedulePromise2 = scheduler.schedule(
+      [request2],
+      abortController.signal,
+    );
+
+    // Ensure the second tool call hasn't been executed yet.
+    expect(mockTool.executeFn).toHaveBeenCalledTimes(1);
+    expect(mockTool.executeFn).toHaveBeenCalledWith({ a: 1 });
+
+    // Complete the first tool call.
+    resolveFirstCall!({
+      llmContent: 'First call complete',
+      returnDisplay: 'First call complete',
+    });
+
+    // Wait for the second schedule promise to resolve.
+    await schedulePromise2;
+
+    // Wait for the second call to be in the 'executing' state.
+    await vi.waitFor(() => {
+      const calls = onToolCallsUpdate.mock.calls.at(-1)?.[0] as ToolCall[];
+      expect(calls?.[0]?.status).toBe('executing');
+    });
+
+    // Now the second tool call should have been executed.
+    expect(mockTool.executeFn).toHaveBeenCalledTimes(2);
+    expect(mockTool.executeFn).toHaveBeenCalledWith({ b: 2 });
+
+    // Let the second call finish.
+    const secondCallResult = {
+      llmContent: 'Second call complete',
+      returnDisplay: 'Second call complete',
+    };
+    // Since the mock is shared, we need to resolve the current promise.
+    // In a real scenario, a new promise would be created for the second call.
+    resolveFirstCall!(secondCallResult);
+
+    // Wait for the second completion.
+    await vi.waitFor(() => {
+      expect(onAllToolCallsComplete).toHaveBeenCalledTimes(2);
+    });
+
+    // Verify the completion callbacks were called correctly.
+    expect(onAllToolCallsComplete.mock.calls[0][0][0].status).toBe('success');
+    expect(onAllToolCallsComplete.mock.calls[1][0][0].status).toBe('success');
+  });
+
+  it('should handle two synchronous calls to schedule', async () => {
+    const mockTool = new MockTool();
+    const declarativeTool = mockTool;
+    const mockToolRegistry = {
+      getTool: () => declarativeTool,
+      getToolByName: () => declarativeTool,
+      getFunctionDeclarations: () => [],
+      tools: new Map(),
+      discovery: {},
+      registerTool: () => {},
+      getToolByDisplayName: () => declarativeTool,
+      getTools: () => [],
+      discoverTools: async () => {},
+      getAllTools: () => [],
+      getToolsByServer: () => [],
+    } as unknown as ToolRegistry;
+
+    const onAllToolCallsComplete = vi.fn();
+    const onToolCallsUpdate = vi.fn();
+
+    const mockConfig = {
+      getSessionId: () => 'test-session-id',
+      getUsageStatisticsEnabled: () => true,
+      getDebugMode: () => false,
+      getApprovalMode: () => ApprovalMode.YOLO,
+      getContentGeneratorConfig: () => ({
+        model: 'test-model',
+        authType: 'oauth-personal',
+      }),
+    } as unknown as Config;
+
+    const scheduler = new CoreToolScheduler({
+      config: mockConfig,
+      toolRegistry: mockToolRegistry,
+      onAllToolCallsComplete,
+      onToolCallsUpdate,
+      getPreferredEditor: () => 'vscode',
+      onEditorClose: vi.fn(),
+    });
+
+    const abortController = new AbortController();
+    const request1 = {
+      callId: '1',
+      name: 'mockTool',
+      args: { a: 1 },
+      isClientInitiated: false,
+      prompt_id: 'prompt-1',
+    };
+    const request2 = {
+      callId: '2',
+      name: 'mockTool',
+      args: { b: 2 },
+      isClientInitiated: false,
+      prompt_id: 'prompt-2',
+    };
+
+    // Schedule two calls synchronously.
+    const schedulePromise1 = scheduler.schedule(
+      [request1],
+      abortController.signal,
+    );
+    const schedulePromise2 = scheduler.schedule(
+      [request2],
+      abortController.signal,
+    );
+
+    // Wait for both promises to resolve.
+    await Promise.all([schedulePromise1, schedulePromise2]);
+
+    // Ensure the tool was called twice with the correct arguments.
+    expect(mockTool.executeFn).toHaveBeenCalledTimes(2);
+    expect(mockTool.executeFn).toHaveBeenCalledWith({ a: 1 });
+    expect(mockTool.executeFn).toHaveBeenCalledWith({ b: 2 });
+
+    // Ensure completion callbacks were called twice.
+    expect(onAllToolCallsComplete).toHaveBeenCalledTimes(2);
+  });
+
+  it('should auto-approve remaining tool calls when first tool call is approved with ProceedAlways', async () => {
+    let approvalMode = ApprovalMode.DEFAULT;
+    const mockConfig = {
+      getSessionId: () => 'test-session-id',
+      getUsageStatisticsEnabled: () => true,
+      getDebugMode: () => false,
+      getApprovalMode: () => approvalMode,
+      setApprovalMode: (mode: ApprovalMode) => {
+        approvalMode = mode;
+      },
+    } as unknown as Config;
+
+    const testTool = new TestApprovalTool(mockConfig);
+    const toolRegistry = {
+      getTool: () => testTool,
+      getFunctionDeclarations: () => [],
+      getFunctionDeclarationsFiltered: () => [],
+      registerTool: () => {},
+      discoverAllTools: async () => {},
+      discoverMcpTools: async () => {},
+      discoverToolsForServer: async () => {},
+      removeMcpToolsByServer: () => {},
+      getAllTools: () => [],
+      getToolsByServer: () => [],
+      tools: new Map(),
+      config: mockConfig,
+      mcpClientManager: undefined,
+      getToolByName: () => testTool,
+      getToolByDisplayName: () => testTool,
+      getTools: () => [],
+      discoverTools: async () => {},
+      discovery: {},
+    };
+
+    const onAllToolCallsComplete = vi.fn();
+    const onToolCallsUpdate = vi.fn();
+    const pendingConfirmations: Array<
+      (outcome: ToolConfirmationOutcome) => void
+    > = [];
+
+    const scheduler = new CoreToolScheduler({
+      config: mockConfig,
+      toolRegistry: toolRegistry as unknown as ToolRegistry,
+      onAllToolCallsComplete,
+      onToolCallsUpdate: (toolCalls) => {
+        onToolCallsUpdate(toolCalls);
+        // Capture confirmation handlers for awaiting_approval tools
+        toolCalls.forEach((call) => {
+          if (call.status === 'awaiting_approval') {
+            const waitingCall = call as WaitingToolCall;
+            if (waitingCall.confirmationDetails?.onConfirm) {
+              const originalHandler = pendingConfirmations.find(
+                (h) => h === waitingCall.confirmationDetails.onConfirm,
+              );
+              if (!originalHandler) {
+                pendingConfirmations.push(
+                  waitingCall.confirmationDetails.onConfirm,
+                );
+              }
+            }
+          }
+        });
+      },
+      getPreferredEditor: () => 'vscode',
+      onEditorClose: vi.fn(),
+    });
+
+    const abortController = new AbortController();
+
+    // Schedule multiple tools that need confirmation
+    const requests = [
+      {
+        callId: '1',
+        name: 'testApprovalTool',
+        args: { id: 'first' },
+        isClientInitiated: false,
+        prompt_id: 'prompt-1',
+      },
+      {
+        callId: '2',
+        name: 'testApprovalTool',
+        args: { id: 'second' },
+        isClientInitiated: false,
+        prompt_id: 'prompt-2',
+      },
+      {
+        callId: '3',
+        name: 'testApprovalTool',
+        args: { id: 'third' },
+        isClientInitiated: false,
+        prompt_id: 'prompt-3',
+      },
+    ];
+
+    await scheduler.schedule(requests, abortController.signal);
+
+    // Wait for all tools to be awaiting approval
+    await vi.waitFor(() => {
+      const calls = onToolCallsUpdate.mock.calls.at(-1)?.[0] as ToolCall[];
+      expect(calls?.length).toBe(3);
+      expect(calls?.every((call) => call.status === 'awaiting_approval')).toBe(
+        true,
+      );
+    });
+
+    expect(pendingConfirmations.length).toBe(3);
+
+    // Approve the first tool with ProceedAlways
+    const firstConfirmation = pendingConfirmations[0];
+    firstConfirmation(ToolConfirmationOutcome.ProceedAlways);
+
+    // Wait for all tools to be completed
+    await vi.waitFor(() => {
+      expect(onAllToolCallsComplete).toHaveBeenCalled();
+      const completedCalls = onAllToolCallsComplete.mock.calls.at(
+        -1,
+      )?.[0] as ToolCall[];
+      expect(completedCalls?.length).toBe(3);
+      expect(completedCalls?.every((call) => call.status === 'success')).toBe(
+        true,
+      );
+    });
+
+    // Verify approval mode was changed
+    expect(approvalMode).toBe(ApprovalMode.AUTO_EDIT);
+  });
+});

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

@@ -0,0 +1,966 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import {
+  ToolCallRequestInfo,
+  ToolCallResponseInfo,
+  ToolConfirmationOutcome,
+  ToolCallConfirmationDetails,
+  ToolResult,
+  ToolResultDisplay,
+  ToolRegistry,
+  ApprovalMode,
+  EditorType,
+  Config,
+  logToolCall,
+  ToolCallEvent,
+  ToolConfirmationPayload,
+  ToolErrorType,
+  AnyDeclarativeTool,
+  AnyToolInvocation,
+} from '../index.js';
+import { Part, PartListUnion } from '@google/genai';
+import { getResponseTextFromParts } from '../utils/generateContentResponseUtilities.js';
+import {
+  isModifiableDeclarativeTool,
+  ModifyContext,
+  modifyWithEditor,
+} from '../tools/modifiable-tool.js';
+import * as Diff from 'diff';
+
+export type ValidatingToolCall = {
+  status: 'validating';
+  request: ToolCallRequestInfo;
+  tool: AnyDeclarativeTool;
+  invocation: AnyToolInvocation;
+  startTime?: number;
+  outcome?: ToolConfirmationOutcome;
+};
+
+export type ScheduledToolCall = {
+  status: 'scheduled';
+  request: ToolCallRequestInfo;
+  tool: AnyDeclarativeTool;
+  invocation: AnyToolInvocation;
+  startTime?: number;
+  outcome?: ToolConfirmationOutcome;
+};
+
+export type ErroredToolCall = {
+  status: 'error';
+  request: ToolCallRequestInfo;
+  response: ToolCallResponseInfo;
+  tool?: AnyDeclarativeTool;
+  durationMs?: number;
+  outcome?: ToolConfirmationOutcome;
+};
+
+export type SuccessfulToolCall = {
+  status: 'success';
+  request: ToolCallRequestInfo;
+  tool: AnyDeclarativeTool;
+  response: ToolCallResponseInfo;
+  invocation: AnyToolInvocation;
+  durationMs?: number;
+  outcome?: ToolConfirmationOutcome;
+};
+
+export type ExecutingToolCall = {
+  status: 'executing';
+  request: ToolCallRequestInfo;
+  tool: AnyDeclarativeTool;
+  invocation: AnyToolInvocation;
+  liveOutput?: string;
+  startTime?: number;
+  outcome?: ToolConfirmationOutcome;
+};
+
+export type CancelledToolCall = {
+  status: 'cancelled';
+  request: ToolCallRequestInfo;
+  response: ToolCallResponseInfo;
+  tool: AnyDeclarativeTool;
+  invocation: AnyToolInvocation;
+  durationMs?: number;
+  outcome?: ToolConfirmationOutcome;
+};
+
+export type WaitingToolCall = {
+  status: 'awaiting_approval';
+  request: ToolCallRequestInfo;
+  tool: AnyDeclarativeTool;
+  invocation: AnyToolInvocation;
+  confirmationDetails: ToolCallConfirmationDetails;
+  startTime?: number;
+  outcome?: ToolConfirmationOutcome;
+};
+
+export type Status = ToolCall['status'];
+
+export type ToolCall =
+  | ValidatingToolCall
+  | ScheduledToolCall
+  | ErroredToolCall
+  | SuccessfulToolCall
+  | ExecutingToolCall
+  | CancelledToolCall
+  | WaitingToolCall;
+
+export type CompletedToolCall =
+  | SuccessfulToolCall
+  | CancelledToolCall
+  | ErroredToolCall;
+
+export type ConfirmHandler = (
+  toolCall: WaitingToolCall,
+) => Promise<ToolConfirmationOutcome>;
+
+export type OutputUpdateHandler = (
+  toolCallId: string,
+  outputChunk: string,
+) => void;
+
+export type AllToolCallsCompleteHandler = (
+  completedToolCalls: CompletedToolCall[],
+) => Promise<void>;
+
+export type ToolCallsUpdateHandler = (toolCalls: ToolCall[]) => void;
+
+/**
+ * Formats tool output for a Gemini FunctionResponse.
+ */
+function createFunctionResponsePart(
+  callId: string,
+  toolName: string,
+  output: string,
+): Part {
+  return {
+    functionResponse: {
+      id: callId,
+      name: toolName,
+      response: { output },
+    },
+  };
+}
+
+export function convertToFunctionResponse(
+  toolName: string,
+  callId: string,
+  llmContent: PartListUnion,
+): PartListUnion {
+  const contentToProcess =
+    Array.isArray(llmContent) && llmContent.length === 1
+      ? llmContent[0]
+      : llmContent;
+
+  if (typeof contentToProcess === 'string') {
+    return createFunctionResponsePart(callId, toolName, contentToProcess);
+  }
+
+  if (Array.isArray(contentToProcess)) {
+    const functionResponse = createFunctionResponsePart(
+      callId,
+      toolName,
+      'Tool execution succeeded.',
+    );
+    return [functionResponse, ...contentToProcess];
+  }
+
+  // After this point, contentToProcess is a single Part object.
+  if (contentToProcess.functionResponse) {
+    if (contentToProcess.functionResponse.response?.['content']) {
+      const stringifiedOutput =
+        getResponseTextFromParts(
+          contentToProcess.functionResponse.response['content'] as Part[],
+        ) || '';
+      return createFunctionResponsePart(callId, toolName, stringifiedOutput);
+    }
+    // It's a functionResponse that we should pass through as is.
+    return contentToProcess;
+  }
+
+  if (contentToProcess.inlineData || contentToProcess.fileData) {
+    const mimeType =
+      contentToProcess.inlineData?.mimeType ||
+      contentToProcess.fileData?.mimeType ||
+      'unknown';
+    const functionResponse = createFunctionResponsePart(
+      callId,
+      toolName,
+      `Binary content of type ${mimeType} was processed.`,
+    );
+    return [functionResponse, contentToProcess];
+  }
+
+  if (contentToProcess.text !== undefined) {
+    return createFunctionResponsePart(callId, toolName, contentToProcess.text);
+  }
+
+  // Default case for other kinds of parts.
+  return createFunctionResponsePart(
+    callId,
+    toolName,
+    'Tool execution succeeded.',
+  );
+}
+
+const createErrorResponse = (
+  request: ToolCallRequestInfo,
+  error: Error,
+  errorType: ToolErrorType | undefined,
+): ToolCallResponseInfo => ({
+  callId: request.callId,
+  error,
+  responseParts: {
+    functionResponse: {
+      id: request.callId,
+      name: request.name,
+      response: { error: error.message },
+    },
+  },
+  resultDisplay: error.message,
+  errorType,
+});
+
+interface CoreToolSchedulerOptions {
+  toolRegistry: ToolRegistry;
+  outputUpdateHandler?: OutputUpdateHandler;
+  onAllToolCallsComplete?: AllToolCallsCompleteHandler;
+  onToolCallsUpdate?: ToolCallsUpdateHandler;
+  getPreferredEditor: () => EditorType | undefined;
+  config: Config;
+  onEditorClose: () => void;
+}
+
+export class CoreToolScheduler {
+  private toolRegistry: ToolRegistry;
+  private toolCalls: ToolCall[] = [];
+  private outputUpdateHandler?: OutputUpdateHandler;
+  private onAllToolCallsComplete?: AllToolCallsCompleteHandler;
+  private onToolCallsUpdate?: ToolCallsUpdateHandler;
+  private getPreferredEditor: () => EditorType | undefined;
+  private config: Config;
+  private onEditorClose: () => void;
+  private isFinalizingToolCalls = false;
+  private isScheduling = false;
+  private requestQueue: Array<{
+    request: ToolCallRequestInfo | ToolCallRequestInfo[];
+    signal: AbortSignal;
+    resolve: () => void;
+    reject: (reason?: Error) => void;
+  }> = [];
+
+  constructor(options: CoreToolSchedulerOptions) {
+    this.config = options.config;
+    this.toolRegistry = options.toolRegistry;
+    this.outputUpdateHandler = options.outputUpdateHandler;
+    this.onAllToolCallsComplete = options.onAllToolCallsComplete;
+    this.onToolCallsUpdate = options.onToolCallsUpdate;
+    this.getPreferredEditor = options.getPreferredEditor;
+    this.onEditorClose = options.onEditorClose;
+  }
+
+  private setStatusInternal(
+    targetCallId: string,
+    status: 'success',
+    response: ToolCallResponseInfo,
+  ): void;
+  private setStatusInternal(
+    targetCallId: string,
+    status: 'awaiting_approval',
+    confirmationDetails: ToolCallConfirmationDetails,
+  ): void;
+  private setStatusInternal(
+    targetCallId: string,
+    status: 'error',
+    response: ToolCallResponseInfo,
+  ): void;
+  private setStatusInternal(
+    targetCallId: string,
+    status: 'cancelled',
+    reason: string,
+  ): void;
+  private setStatusInternal(
+    targetCallId: string,
+    status: 'executing' | 'scheduled' | 'validating',
+  ): void;
+  private setStatusInternal(
+    targetCallId: string,
+    newStatus: Status,
+    auxiliaryData?: unknown,
+  ): void {
+    this.toolCalls = this.toolCalls.map((currentCall) => {
+      if (
+        currentCall.request.callId !== targetCallId ||
+        currentCall.status === 'success' ||
+        currentCall.status === 'error' ||
+        currentCall.status === 'cancelled'
+      ) {
+        return currentCall;
+      }
+
+      // currentCall is a non-terminal state here and should have startTime and tool.
+      const existingStartTime = currentCall.startTime;
+      const toolInstance = currentCall.tool;
+      const invocation = currentCall.invocation;
+
+      const outcome = currentCall.outcome;
+
+      switch (newStatus) {
+        case 'success': {
+          const durationMs = existingStartTime
+            ? Date.now() - existingStartTime
+            : undefined;
+          return {
+            request: currentCall.request,
+            tool: toolInstance,
+            invocation,
+            status: 'success',
+            response: auxiliaryData as ToolCallResponseInfo,
+            durationMs,
+            outcome,
+          } as SuccessfulToolCall;
+        }
+        case 'error': {
+          const durationMs = existingStartTime
+            ? Date.now() - existingStartTime
+            : undefined;
+          return {
+            request: currentCall.request,
+            status: 'error',
+            tool: toolInstance,
+            response: auxiliaryData as ToolCallResponseInfo,
+            durationMs,
+            outcome,
+          } as ErroredToolCall;
+        }
+        case 'awaiting_approval':
+          return {
+            request: currentCall.request,
+            tool: toolInstance,
+            status: 'awaiting_approval',
+            confirmationDetails: auxiliaryData as ToolCallConfirmationDetails,
+            startTime: existingStartTime,
+            outcome,
+            invocation,
+          } as WaitingToolCall;
+        case 'scheduled':
+          return {
+            request: currentCall.request,
+            tool: toolInstance,
+            status: 'scheduled',
+            startTime: existingStartTime,
+            outcome,
+            invocation,
+          } as ScheduledToolCall;
+        case 'cancelled': {
+          const durationMs = existingStartTime
+            ? Date.now() - existingStartTime
+            : undefined;
+
+          // Preserve diff for cancelled edit operations
+          let resultDisplay: ToolResultDisplay | undefined = undefined;
+          if (currentCall.status === 'awaiting_approval') {
+            const waitingCall = currentCall as WaitingToolCall;
+            if (waitingCall.confirmationDetails.type === 'edit') {
+              resultDisplay = {
+                fileDiff: waitingCall.confirmationDetails.fileDiff,
+                fileName: waitingCall.confirmationDetails.fileName,
+                originalContent:
+                  waitingCall.confirmationDetails.originalContent,
+                newContent: waitingCall.confirmationDetails.newContent,
+              };
+            }
+          }
+
+          return {
+            request: currentCall.request,
+            tool: toolInstance,
+            invocation,
+            status: 'cancelled',
+            response: {
+              callId: currentCall.request.callId,
+              responseParts: {
+                functionResponse: {
+                  id: currentCall.request.callId,
+                  name: currentCall.request.name,
+                  response: {
+                    error: `[Operation Cancelled] Reason: ${auxiliaryData}`,
+                  },
+                },
+              },
+              resultDisplay,
+              error: undefined,
+              errorType: undefined,
+            },
+            durationMs,
+            outcome,
+          } as CancelledToolCall;
+        }
+        case 'validating':
+          return {
+            request: currentCall.request,
+            tool: toolInstance,
+            status: 'validating',
+            startTime: existingStartTime,
+            outcome,
+            invocation,
+          } as ValidatingToolCall;
+        case 'executing':
+          return {
+            request: currentCall.request,
+            tool: toolInstance,
+            status: 'executing',
+            startTime: existingStartTime,
+            outcome,
+            invocation,
+          } as ExecutingToolCall;
+        default: {
+          const exhaustiveCheck: never = newStatus;
+          return exhaustiveCheck;
+        }
+      }
+    });
+    this.notifyToolCallsUpdate();
+    this.checkAndNotifyCompletion();
+  }
+
+  private setArgsInternal(targetCallId: string, args: unknown): void {
+    this.toolCalls = this.toolCalls.map((call) => {
+      // We should never be asked to set args on an ErroredToolCall, but
+      // we guard for the case anyways.
+      if (call.request.callId !== targetCallId || call.status === 'error') {
+        return call;
+      }
+
+      const invocationOrError = this.buildInvocation(
+        call.tool,
+        args as Record<string, unknown>,
+      );
+      if (invocationOrError instanceof Error) {
+        const response = createErrorResponse(
+          call.request,
+          invocationOrError,
+          ToolErrorType.INVALID_TOOL_PARAMS,
+        );
+        return {
+          request: { ...call.request, args: args as Record<string, unknown> },
+          status: 'error',
+          tool: call.tool,
+          response,
+        } as ErroredToolCall;
+      }
+
+      return {
+        ...call,
+        request: { ...call.request, args: args as Record<string, unknown> },
+        invocation: invocationOrError,
+      };
+    });
+  }
+
+  private isRunning(): boolean {
+    return (
+      this.isFinalizingToolCalls ||
+      this.toolCalls.some(
+        (call) =>
+          call.status === 'executing' || call.status === 'awaiting_approval',
+      )
+    );
+  }
+
+  private buildInvocation(
+    tool: AnyDeclarativeTool,
+    args: object,
+  ): AnyToolInvocation | Error {
+    try {
+      return tool.build(args);
+    } catch (e) {
+      if (e instanceof Error) {
+        return e;
+      }
+      return new Error(String(e));
+    }
+  }
+
+  schedule(
+    request: ToolCallRequestInfo | ToolCallRequestInfo[],
+    signal: AbortSignal,
+  ): Promise<void> {
+    if (this.isRunning() || this.isScheduling) {
+      return new Promise((resolve, reject) => {
+        const abortHandler = () => {
+          // Find and remove the request from the queue
+          const index = this.requestQueue.findIndex(
+            (item) => item.request === request,
+          );
+          if (index > -1) {
+            this.requestQueue.splice(index, 1);
+            reject(new Error('Tool call cancelled while in queue.'));
+          }
+        };
+
+        signal.addEventListener('abort', abortHandler, { once: true });
+
+        this.requestQueue.push({
+          request,
+          signal,
+          resolve: () => {
+            signal.removeEventListener('abort', abortHandler);
+            resolve();
+          },
+          reject: (reason?: Error) => {
+            signal.removeEventListener('abort', abortHandler);
+            reject(reason);
+          },
+        });
+      });
+    }
+    return this._schedule(request, signal);
+  }
+
+  private async _schedule(
+    request: ToolCallRequestInfo | ToolCallRequestInfo[],
+    signal: AbortSignal,
+  ): Promise<void> {
+    this.isScheduling = true;
+    try {
+      if (this.isRunning()) {
+        throw new Error(
+          'Cannot schedule new tool calls while other tool calls are actively running (executing or awaiting approval).',
+        );
+      }
+      const requestsToProcess = Array.isArray(request) ? request : [request];
+
+      const newToolCalls: ToolCall[] = requestsToProcess.map(
+        (reqInfo): ToolCall => {
+          const toolInstance = this.toolRegistry.getTool(reqInfo.name);
+          if (!toolInstance) {
+            return {
+              status: 'error',
+              request: reqInfo,
+              response: createErrorResponse(
+                reqInfo,
+                new Error(`Tool "${reqInfo.name}" not found in registry.`),
+                ToolErrorType.TOOL_NOT_REGISTERED,
+              ),
+              durationMs: 0,
+            };
+          }
+
+          const invocationOrError = this.buildInvocation(
+            toolInstance,
+            reqInfo.args,
+          );
+          if (invocationOrError instanceof Error) {
+            return {
+              status: 'error',
+              request: reqInfo,
+              tool: toolInstance,
+              response: createErrorResponse(
+                reqInfo,
+                invocationOrError,
+                ToolErrorType.INVALID_TOOL_PARAMS,
+              ),
+              durationMs: 0,
+            };
+          }
+
+          return {
+            status: 'validating',
+            request: reqInfo,
+            tool: toolInstance,
+            invocation: invocationOrError,
+            startTime: Date.now(),
+          };
+        },
+      );
+
+      this.toolCalls = this.toolCalls.concat(newToolCalls);
+      this.notifyToolCallsUpdate();
+
+      for (const toolCall of newToolCalls) {
+        if (toolCall.status !== 'validating') {
+          continue;
+        }
+
+        const { request: reqInfo, invocation } = toolCall;
+
+        try {
+          if (signal.aborted) {
+            this.setStatusInternal(
+              reqInfo.callId,
+              'cancelled',
+              'Tool call cancelled by user.',
+            );
+            continue;
+          }
+          if (this.config.getApprovalMode() === ApprovalMode.YOLO) {
+            this.setToolCallOutcome(
+              reqInfo.callId,
+              ToolConfirmationOutcome.ProceedAlways,
+            );
+            this.setStatusInternal(reqInfo.callId, 'scheduled');
+          } else {
+            const confirmationDetails =
+              await invocation.shouldConfirmExecute(signal);
+
+            if (confirmationDetails) {
+              // Allow IDE to resolve confirmation
+              if (
+                confirmationDetails.type === 'edit' &&
+                confirmationDetails.ideConfirmation
+              ) {
+                confirmationDetails.ideConfirmation.then((resolution) => {
+                  if (resolution.status === 'accepted') {
+                    this.handleConfirmationResponse(
+                      reqInfo.callId,
+                      confirmationDetails.onConfirm,
+                      ToolConfirmationOutcome.ProceedOnce,
+                      signal,
+                    );
+                  } else {
+                    this.handleConfirmationResponse(
+                      reqInfo.callId,
+                      confirmationDetails.onConfirm,
+                      ToolConfirmationOutcome.Cancel,
+                      signal,
+                    );
+                  }
+                });
+              }
+
+              const originalOnConfirm = confirmationDetails.onConfirm;
+              const wrappedConfirmationDetails: ToolCallConfirmationDetails = {
+                ...confirmationDetails,
+                onConfirm: (
+                  outcome: ToolConfirmationOutcome,
+                  payload?: ToolConfirmationPayload,
+                ) =>
+                  this.handleConfirmationResponse(
+                    reqInfo.callId,
+                    originalOnConfirm,
+                    outcome,
+                    signal,
+                    payload,
+                  ),
+              };
+              this.setStatusInternal(
+                reqInfo.callId,
+                'awaiting_approval',
+                wrappedConfirmationDetails,
+              );
+            } else {
+              this.setToolCallOutcome(
+                reqInfo.callId,
+                ToolConfirmationOutcome.ProceedAlways,
+              );
+              this.setStatusInternal(reqInfo.callId, 'scheduled');
+            }
+          }
+        } catch (error) {
+          this.setStatusInternal(
+            reqInfo.callId,
+            'error',
+            createErrorResponse(
+              reqInfo,
+              error instanceof Error ? error : new Error(String(error)),
+              ToolErrorType.UNHANDLED_EXCEPTION,
+            ),
+          );
+        }
+      }
+      this.attemptExecutionOfScheduledCalls(signal);
+      void this.checkAndNotifyCompletion();
+    } finally {
+      this.isScheduling = false;
+    }
+  }
+
+  async handleConfirmationResponse(
+    callId: string,
+    originalOnConfirm: (outcome: ToolConfirmationOutcome) => Promise<void>,
+    outcome: ToolConfirmationOutcome,
+    signal: AbortSignal,
+    payload?: ToolConfirmationPayload,
+  ): Promise<void> {
+    const toolCall = this.toolCalls.find(
+      (c) => c.request.callId === callId && c.status === 'awaiting_approval',
+    );
+
+    if (toolCall && toolCall.status === 'awaiting_approval') {
+      await originalOnConfirm(outcome);
+    }
+
+    if (outcome === ToolConfirmationOutcome.ProceedAlways) {
+      await this.autoApproveCompatiblePendingTools(signal, callId);
+    }
+
+    this.setToolCallOutcome(callId, outcome);
+
+    if (outcome === ToolConfirmationOutcome.Cancel || signal.aborted) {
+      this.setStatusInternal(
+        callId,
+        'cancelled',
+        'User did not allow tool call',
+      );
+    } else if (outcome === ToolConfirmationOutcome.ModifyWithEditor) {
+      const waitingToolCall = toolCall as WaitingToolCall;
+      if (isModifiableDeclarativeTool(waitingToolCall.tool)) {
+        const modifyContext = waitingToolCall.tool.getModifyContext(signal);
+        const editorType = this.getPreferredEditor();
+        if (!editorType) {
+          return;
+        }
+
+        this.setStatusInternal(callId, 'awaiting_approval', {
+          ...waitingToolCall.confirmationDetails,
+          isModifying: true,
+        } as ToolCallConfirmationDetails);
+
+        const { updatedParams, updatedDiff } = await modifyWithEditor<
+          typeof waitingToolCall.request.args
+        >(
+          waitingToolCall.request.args,
+          modifyContext as ModifyContext<typeof waitingToolCall.request.args>,
+          editorType,
+          signal,
+          this.onEditorClose,
+        );
+        this.setArgsInternal(callId, updatedParams);
+        this.setStatusInternal(callId, 'awaiting_approval', {
+          ...waitingToolCall.confirmationDetails,
+          fileDiff: updatedDiff,
+          isModifying: false,
+        } as ToolCallConfirmationDetails);
+      }
+    } else {
+      // If the client provided new content, apply it before scheduling.
+      if (payload?.newContent && toolCall) {
+        await this._applyInlineModify(
+          toolCall as WaitingToolCall,
+          payload,
+          signal,
+        );
+      }
+      this.setStatusInternal(callId, 'scheduled');
+    }
+    this.attemptExecutionOfScheduledCalls(signal);
+  }
+
+  /**
+   * Applies user-provided content changes to a tool call that is awaiting confirmation.
+   * This method updates the tool's arguments and refreshes the confirmation prompt with a new diff
+   * before the tool is scheduled for execution.
+   * @private
+   */
+  private async _applyInlineModify(
+    toolCall: WaitingToolCall,
+    payload: ToolConfirmationPayload,
+    signal: AbortSignal,
+  ): Promise<void> {
+    if (
+      toolCall.confirmationDetails.type !== 'edit' ||
+      !isModifiableDeclarativeTool(toolCall.tool)
+    ) {
+      return;
+    }
+
+    const modifyContext = toolCall.tool.getModifyContext(signal);
+    const currentContent = await modifyContext.getCurrentContent(
+      toolCall.request.args,
+    );
+
+    const updatedParams = modifyContext.createUpdatedParams(
+      currentContent,
+      payload.newContent,
+      toolCall.request.args,
+    );
+    const updatedDiff = Diff.createPatch(
+      modifyContext.getFilePath(toolCall.request.args),
+      currentContent,
+      payload.newContent,
+      'Current',
+      'Proposed',
+    );
+
+    this.setArgsInternal(toolCall.request.callId, updatedParams);
+    this.setStatusInternal(toolCall.request.callId, 'awaiting_approval', {
+      ...toolCall.confirmationDetails,
+      fileDiff: updatedDiff,
+    });
+  }
+
+  private attemptExecutionOfScheduledCalls(signal: AbortSignal): void {
+    const allCallsFinalOrScheduled = this.toolCalls.every(
+      (call) =>
+        call.status === 'scheduled' ||
+        call.status === 'cancelled' ||
+        call.status === 'success' ||
+        call.status === 'error',
+    );
+
+    if (allCallsFinalOrScheduled) {
+      const callsToExecute = this.toolCalls.filter(
+        (call) => call.status === 'scheduled',
+      );
+
+      callsToExecute.forEach((toolCall) => {
+        if (toolCall.status !== 'scheduled') return;
+
+        const scheduledCall = toolCall;
+        const { callId, name: toolName } = scheduledCall.request;
+        const invocation = scheduledCall.invocation;
+        this.setStatusInternal(callId, 'executing');
+
+        const liveOutputCallback =
+          scheduledCall.tool.canUpdateOutput && this.outputUpdateHandler
+            ? (outputChunk: string) => {
+                if (this.outputUpdateHandler) {
+                  this.outputUpdateHandler(callId, outputChunk);
+                }
+                this.toolCalls = this.toolCalls.map((tc) =>
+                  tc.request.callId === callId && tc.status === 'executing'
+                    ? { ...tc, liveOutput: outputChunk }
+                    : tc,
+                );
+                this.notifyToolCallsUpdate();
+              }
+            : undefined;
+
+        invocation
+          .execute(signal, liveOutputCallback)
+          .then(async (toolResult: ToolResult) => {
+            if (signal.aborted) {
+              this.setStatusInternal(
+                callId,
+                'cancelled',
+                'User cancelled tool execution.',
+              );
+              return;
+            }
+
+            if (toolResult.error === undefined) {
+              const response = convertToFunctionResponse(
+                toolName,
+                callId,
+                toolResult.llmContent,
+              );
+              const successResponse: ToolCallResponseInfo = {
+                callId,
+                responseParts: response,
+                resultDisplay: toolResult.returnDisplay,
+                error: undefined,
+                errorType: undefined,
+              };
+              this.setStatusInternal(callId, 'success', successResponse);
+            } else {
+              // It is a failure
+              const error = new Error(toolResult.error.message);
+              const errorResponse = createErrorResponse(
+                scheduledCall.request,
+                error,
+                toolResult.error.type,
+              );
+              this.setStatusInternal(callId, 'error', errorResponse);
+            }
+          })
+          .catch((executionError: Error) => {
+            this.setStatusInternal(
+              callId,
+              'error',
+              createErrorResponse(
+                scheduledCall.request,
+                executionError instanceof Error
+                  ? executionError
+                  : new Error(String(executionError)),
+                ToolErrorType.UNHANDLED_EXCEPTION,
+              ),
+            );
+          });
+      });
+    }
+  }
+
+  private async checkAndNotifyCompletion(): Promise<void> {
+    const allCallsAreTerminal = this.toolCalls.every(
+      (call) =>
+        call.status === 'success' ||
+        call.status === 'error' ||
+        call.status === 'cancelled',
+    );
+
+    if (this.toolCalls.length > 0 && allCallsAreTerminal) {
+      const completedCalls = [...this.toolCalls] as CompletedToolCall[];
+      this.toolCalls = [];
+
+      for (const call of completedCalls) {
+        logToolCall(this.config, new ToolCallEvent(call));
+      }
+
+      if (this.onAllToolCallsComplete) {
+        this.isFinalizingToolCalls = true;
+        await this.onAllToolCallsComplete(completedCalls);
+        this.isFinalizingToolCalls = false;
+      }
+      this.notifyToolCallsUpdate();
+      // After completion, process the next item in the queue.
+      if (this.requestQueue.length > 0) {
+        const next = this.requestQueue.shift()!;
+        this._schedule(next.request, next.signal)
+          .then(next.resolve)
+          .catch(next.reject);
+      }
+    }
+  }
+
+  private notifyToolCallsUpdate(): void {
+    if (this.onToolCallsUpdate) {
+      this.onToolCallsUpdate([...this.toolCalls]);
+    }
+  }
+
+  private setToolCallOutcome(callId: string, outcome: ToolConfirmationOutcome) {
+    this.toolCalls = this.toolCalls.map((call) => {
+      if (call.request.callId !== callId) return call;
+      return {
+        ...call,
+        outcome,
+      };
+    });
+  }
+
+  private async autoApproveCompatiblePendingTools(
+    signal: AbortSignal,
+    triggeringCallId: string,
+  ): Promise<void> {
+    const pendingTools = this.toolCalls.filter(
+      (call) =>
+        call.status === 'awaiting_approval' &&
+        call.request.callId !== triggeringCallId,
+    ) as WaitingToolCall[];
+
+    for (const pendingTool of pendingTools) {
+      try {
+        const stillNeedsConfirmation =
+          await pendingTool.invocation.shouldConfirmExecute(signal);
+
+        if (!stillNeedsConfirmation) {
+          this.setToolCallOutcome(
+            pendingTool.request.callId,
+            ToolConfirmationOutcome.ProceedAlways,
+          );
+          this.setStatusInternal(pendingTool.request.callId, 'scheduled');
+        }
+      } catch (error) {
+        console.error(
+          `Error checking confirmation for tool ${pendingTool.request.callId}:`,
+          error,
+        );
+      }
+    }
+  }
+}

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

@@ -0,0 +1,890 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import {
+  Content,
+  Models,
+  GenerateContentConfig,
+  Part,
+  GenerateContentResponse,
+} from '@google/genai';
+import { GeminiChat, EmptyStreamError } from './geminiChat.js';
+import { Config } from '../config/config.js';
+import { setSimulate429 } from '../utils/testUtils.js';
+
+// Mocks
+const mockModelsModule = {
+  generateContent: vi.fn(),
+  generateContentStream: vi.fn(),
+  countTokens: vi.fn(),
+  embedContent: vi.fn(),
+  batchEmbedContents: vi.fn(),
+} as unknown as Models;
+
+const { mockLogInvalidChunk, mockLogContentRetry, mockLogContentRetryFailure } =
+  vi.hoisted(() => ({
+    mockLogInvalidChunk: vi.fn(),
+    mockLogContentRetry: vi.fn(),
+    mockLogContentRetryFailure: vi.fn(),
+  }));
+
+vi.mock('../telemetry/loggers.js', () => ({
+  logInvalidChunk: mockLogInvalidChunk,
+  logContentRetry: mockLogContentRetry,
+  logContentRetryFailure: mockLogContentRetryFailure,
+}));
+
+describe('GeminiChat', () => {
+  let chat: GeminiChat;
+  let mockConfig: Config;
+  const config: GenerateContentConfig = {};
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockConfig = {
+      getSessionId: () => 'test-session-id',
+      getTelemetryLogPromptsEnabled: () => true,
+      getUsageStatisticsEnabled: () => true,
+      getDebugMode: () => false,
+      getContentGeneratorConfig: () => ({
+        authType: 'oauth-personal',
+        model: 'test-model',
+      }),
+      getModel: vi.fn().mockReturnValue('gemini-pro'),
+      setModel: vi.fn(),
+      getQuotaErrorOccurred: vi.fn().mockReturnValue(false),
+      setQuotaErrorOccurred: vi.fn(),
+      flashFallbackHandler: undefined,
+    } as unknown as Config;
+
+    // Disable 429 simulation for tests
+    setSimulate429(false);
+    // Reset history for each test by creating a new instance
+    chat = new GeminiChat(mockConfig, mockModelsModule, config, []);
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+    vi.resetAllMocks();
+  });
+
+  describe('sendMessage', () => {
+    it('should call generateContent with the correct parameters', async () => {
+      const response = {
+        candidates: [
+          {
+            content: {
+              parts: [{ text: 'response' }],
+              role: 'model',
+            },
+            finishReason: 'STOP',
+            index: 0,
+            safetyRatings: [],
+          },
+        ],
+        text: () => 'response',
+      } as unknown as GenerateContentResponse;
+      vi.mocked(mockModelsModule.generateContent).mockResolvedValue(response);
+
+      await chat.sendMessage({ message: 'hello' }, 'prompt-id-1');
+
+      expect(mockModelsModule.generateContent).toHaveBeenCalledWith(
+        {
+          model: 'gemini-pro',
+          contents: [{ role: 'user', parts: [{ text: 'hello' }] }],
+          config: {},
+        },
+        'prompt-id-1',
+      );
+    });
+  });
+
+  describe('sendMessageStream', () => {
+    it('should call generateContentStream with the correct parameters', async () => {
+      const response = (async function* () {
+        yield {
+          candidates: [
+            {
+              content: {
+                parts: [{ text: 'response' }],
+                role: 'model',
+              },
+              finishReason: 'STOP',
+              index: 0,
+              safetyRatings: [],
+            },
+          ],
+          text: () => 'response',
+        } as unknown as GenerateContentResponse;
+      })();
+      vi.mocked(mockModelsModule.generateContentStream).mockResolvedValue(
+        response,
+      );
+
+      const stream = await chat.sendMessageStream(
+        { message: 'hello' },
+        'prompt-id-1',
+      );
+      for await (const _ of stream) {
+        // consume stream to trigger internal logic
+      }
+
+      expect(mockModelsModule.generateContentStream).toHaveBeenCalledWith(
+        {
+          model: 'gemini-pro',
+          contents: [{ role: 'user', parts: [{ text: 'hello' }] }],
+          config: {},
+        },
+        'prompt-id-1',
+      );
+    });
+  });
+
+  describe('recordHistory', () => {
+    const userInput: Content = {
+      role: 'user',
+      parts: [{ text: 'User input' }],
+    };
+
+    it('should add user input and a single model output to history', () => {
+      const modelOutput: Content[] = [
+        { role: 'model', parts: [{ text: 'Model output' }] },
+      ];
+      // @ts-expect-error Accessing private method for testing purposes
+      chat.recordHistory(userInput, modelOutput);
+      const history = chat.getHistory();
+      expect(history).toEqual([userInput, modelOutput[0]]);
+    });
+
+    it('should consolidate adjacent model outputs', () => {
+      const modelOutputParts: Content[] = [
+        { role: 'model', parts: [{ text: 'Model part 1' }] },
+        { role: 'model', parts: [{ text: 'Model part 2' }] },
+      ];
+      // @ts-expect-error Accessing private method for testing purposes
+      chat.recordHistory(userInput, modelOutputParts);
+      const history = chat.getHistory();
+      expect(history.length).toBe(2);
+      expect(history[0]).toEqual(userInput);
+      expect(history[1].role).toBe('model');
+      expect(history[1].parts).toEqual([{ text: 'Model part 1Model part 2' }]);
+    });
+
+    it('should handle a mix of user and model roles in outputContents (though unusual)', () => {
+      const mixedOutput: Content[] = [
+        { role: 'model', parts: [{ text: 'Model 1' }] },
+        { role: 'user', parts: [{ text: 'Unexpected User' }] }, // This should be pushed as is
+        { role: 'model', parts: [{ text: 'Model 2' }] },
+      ];
+      // @ts-expect-error Accessing private method for testing purposes
+      chat.recordHistory(userInput, mixedOutput);
+      const history = chat.getHistory();
+      expect(history.length).toBe(4); // user, model1, user_unexpected, model2
+      expect(history[0]).toEqual(userInput);
+      expect(history[1]).toEqual(mixedOutput[0]);
+      expect(history[2]).toEqual(mixedOutput[1]);
+      expect(history[3]).toEqual(mixedOutput[2]);
+    });
+
+    it('should consolidate multiple adjacent model outputs correctly', () => {
+      const modelOutputParts: Content[] = [
+        { role: 'model', parts: [{ text: 'M1' }] },
+        { role: 'model', parts: [{ text: 'M2' }] },
+        { role: 'model', parts: [{ text: 'M3' }] },
+      ];
+      // @ts-expect-error Accessing private method for testing purposes
+      chat.recordHistory(userInput, modelOutputParts);
+      const history = chat.getHistory();
+      expect(history.length).toBe(2);
+      expect(history[1].parts).toEqual([{ text: 'M1M2M3' }]);
+    });
+
+    it('should not consolidate if roles are different between model outputs', () => {
+      const modelOutputParts: Content[] = [
+        { role: 'model', parts: [{ text: 'M1' }] },
+        { role: 'user', parts: [{ text: 'Interjecting User' }] },
+        { role: 'model', parts: [{ text: 'M2' }] },
+      ];
+      // @ts-expect-error Accessing private method for testing purposes
+      chat.recordHistory(userInput, modelOutputParts);
+      const history = chat.getHistory();
+      expect(history.length).toBe(4); // user, M1, Interjecting User, M2
+      expect(history[1].parts).toEqual([{ text: 'M1' }]);
+      expect(history[3].parts).toEqual([{ text: 'M2' }]);
+    });
+
+    it('should merge with last history entry if it is also a model output', () => {
+      // @ts-expect-error Accessing private property for test setup
+      chat.history = [
+        userInput,
+        { role: 'model', parts: [{ text: 'Initial Model Output' }] },
+      ]; // Prime the history
+
+      const newModelOutput: Content[] = [
+        { role: 'model', parts: [{ text: 'New Model Part 1' }] },
+        { role: 'model', parts: [{ text: 'New Model Part 2' }] },
+      ];
+      // @ts-expect-error Accessing private method for testing purposes
+      chat.recordHistory(userInput, newModelOutput); // userInput here is for the *next* turn, but history is already primed
+
+      // Reset and set up a more realistic scenario for merging with existing history
+      chat = new GeminiChat(mockConfig, mockModelsModule, config, []);
+      const firstUserInput: Content = {
+        role: 'user',
+        parts: [{ text: 'First user input' }],
+      };
+      const firstModelOutput: Content[] = [
+        { role: 'model', parts: [{ text: 'First model response' }] },
+      ];
+      // @ts-expect-error Accessing private method for testing purposes
+      chat.recordHistory(firstUserInput, firstModelOutput);
+
+      const secondUserInput: Content = {
+        role: 'user',
+        parts: [{ text: 'Second user input' }],
+      };
+      const secondModelOutput: Content[] = [
+        { role: 'model', parts: [{ text: 'Second model response part 1' }] },
+        { role: 'model', parts: [{ text: 'Second model response part 2' }] },
+      ];
+      // @ts-expect-error Accessing private method for testing purposes
+      chat.recordHistory(secondUserInput, secondModelOutput);
+
+      const finalHistory = chat.getHistory();
+      expect(finalHistory.length).toBe(4); // user1, model1, user2, model2(consolidated)
+      expect(finalHistory[0]).toEqual(firstUserInput);
+      expect(finalHistory[1]).toEqual(firstModelOutput[0]);
+      expect(finalHistory[2]).toEqual(secondUserInput);
+      expect(finalHistory[3].role).toBe('model');
+      expect(finalHistory[3].parts).toEqual([
+        { text: 'Second model response part 1Second model response part 2' },
+      ]);
+    });
+
+    it('should correctly merge consolidated new output with existing model history', () => {
+      // Setup: history ends with a model turn
+      const initialUser: Content = {
+        role: 'user',
+        parts: [{ text: 'Initial user query' }],
+      };
+      const initialModel: Content = {
+        role: 'model',
+        parts: [{ text: 'Initial model answer.' }],
+      };
+      chat = new GeminiChat(mockConfig, mockModelsModule, config, [
+        initialUser,
+        initialModel,
+      ]);
+
+      // New interaction
+      const currentUserInput: Content = {
+        role: 'user',
+        parts: [{ text: 'Follow-up question' }],
+      };
+      const newModelParts: Content[] = [
+        { role: 'model', parts: [{ text: 'Part A of new answer.' }] },
+        { role: 'model', parts: [{ text: 'Part B of new answer.' }] },
+      ];
+
+      // @ts-expect-error Accessing private method for testing purposes
+      chat.recordHistory(currentUserInput, newModelParts);
+      const history = chat.getHistory();
+
+      // Expected: initialUser, initialModel, currentUserInput, consolidatedNewModelParts
+      expect(history.length).toBe(4);
+      expect(history[0]).toEqual(initialUser);
+      expect(history[1]).toEqual(initialModel);
+      expect(history[2]).toEqual(currentUserInput);
+      expect(history[3].role).toBe('model');
+      expect(history[3].parts).toEqual([
+        { text: 'Part A of new answer.Part B of new answer.' },
+      ]);
+    });
+
+    it('should handle empty modelOutput array', () => {
+      // @ts-expect-error Accessing private method for testing purposes
+      chat.recordHistory(userInput, []);
+      const history = chat.getHistory();
+      // If modelOutput is empty, it might push a default empty model part depending on isFunctionResponse
+      // Assuming isFunctionResponse(userInput) is false for this simple text input
+      expect(history.length).toBe(2);
+      expect(history[0]).toEqual(userInput);
+      expect(history[1].role).toBe('model');
+      expect(history[1].parts).toEqual([]);
+    });
+
+    it('should handle aggregating modelOutput', () => {
+      const modelOutputUndefinedParts: Content[] = [
+        { role: 'model', parts: [{ text: 'First model part' }] },
+        { role: 'model', parts: [{ text: 'Second model part' }] },
+        { role: 'model', parts: undefined as unknown as Part[] }, // Test undefined parts
+        { role: 'model', parts: [{ text: 'Third model part' }] },
+        { role: 'model', parts: [] }, // Test empty parts array
+      ];
+      // @ts-expect-error Accessing private method for testing purposes
+      chat.recordHistory(userInput, modelOutputUndefinedParts);
+      const history = chat.getHistory();
+      expect(history.length).toBe(5);
+      expect(history[0]).toEqual(userInput);
+      expect(history[1].role).toBe('model');
+      expect(history[1].parts).toEqual([
+        { text: 'First model partSecond model part' },
+      ]);
+      expect(history[2].role).toBe('model');
+      expect(history[2].parts).toBeUndefined();
+      expect(history[3].role).toBe('model');
+      expect(history[3].parts).toEqual([{ text: 'Third model part' }]);
+      expect(history[4].role).toBe('model');
+      expect(history[4].parts).toEqual([]);
+    });
+
+    it('should handle modelOutput with parts being undefined or empty (if they pass initial every check)', () => {
+      const modelOutputUndefinedParts: Content[] = [
+        { role: 'model', parts: [{ text: 'Text part' }] },
+        { role: 'model', parts: undefined as unknown as Part[] }, // Test undefined parts
+        { role: 'model', parts: [] }, // Test empty parts array
+      ];
+      // @ts-expect-error Accessing private method for testing purposes
+      chat.recordHistory(userInput, modelOutputUndefinedParts);
+      const history = chat.getHistory();
+      expect(history.length).toBe(4); // userInput, model1 (text), model2 (undefined parts), model3 (empty parts)
+      expect(history[0]).toEqual(userInput);
+      expect(history[1].role).toBe('model');
+      expect(history[1].parts).toEqual([{ text: 'Text part' }]);
+      expect(history[2].role).toBe('model');
+      expect(history[2].parts).toBeUndefined();
+      expect(history[3].role).toBe('model');
+      expect(history[3].parts).toEqual([]);
+    });
+
+    it('should correctly handle automaticFunctionCallingHistory', () => {
+      const afcHistory: Content[] = [
+        { role: 'user', parts: [{ text: 'AFC User' }] },
+        { role: 'model', parts: [{ text: 'AFC Model' }] },
+      ];
+      const modelOutput: Content[] = [
+        { role: 'model', parts: [{ text: 'Regular Model Output' }] },
+      ];
+      // @ts-expect-error Accessing private method for testing purposes
+      chat.recordHistory(userInput, modelOutput, afcHistory);
+      const history = chat.getHistory();
+      expect(history.length).toBe(3);
+      expect(history[0]).toEqual(afcHistory[0]);
+      expect(history[1]).toEqual(afcHistory[1]);
+      expect(history[2]).toEqual(modelOutput[0]);
+    });
+
+    it('should add userInput if AFC history is present but empty', () => {
+      const modelOutput: Content[] = [
+        { role: 'model', parts: [{ text: 'Model Output' }] },
+      ];
+      // @ts-expect-error Accessing private method for testing purposes
+      chat.recordHistory(userInput, modelOutput, []); // Empty AFC history
+      const history = chat.getHistory();
+      expect(history.length).toBe(2);
+      expect(history[0]).toEqual(userInput);
+      expect(history[1]).toEqual(modelOutput[0]);
+    });
+
+    it('should skip "thought" content from modelOutput', () => {
+      const modelOutputWithThought: Content[] = [
+        { role: 'model', parts: [{ thought: true }, { text: 'Visible text' }] },
+        { role: 'model', parts: [{ text: 'Another visible text' }] },
+      ];
+      // @ts-expect-error Accessing private method for testing purposes
+      chat.recordHistory(userInput, modelOutputWithThought);
+      const history = chat.getHistory();
+      expect(history.length).toBe(2); // User input + consolidated model output
+      expect(history[0]).toEqual(userInput);
+      expect(history[1].role).toBe('model');
+      // The 'thought' part is skipped, 'Another visible text' becomes the first part.
+      expect(history[1].parts).toEqual([{ text: 'Another visible text' }]);
+    });
+
+    it('should skip "thought" content even if it is the only content', () => {
+      const modelOutputOnlyThought: Content[] = [
+        { role: 'model', parts: [{ thought: true }] },
+      ];
+      // @ts-expect-error Accessing private method for testing purposes
+      chat.recordHistory(userInput, modelOutputOnlyThought);
+      const history = chat.getHistory();
+      expect(history.length).toBe(1); // User input + default empty model part
+      expect(history[0]).toEqual(userInput);
+    });
+
+    it('should correctly consolidate text parts when a thought part is in between', () => {
+      const modelOutputMixed: Content[] = [
+        { role: 'model', parts: [{ text: 'Part 1.' }] },
+        {
+          role: 'model',
+          parts: [{ thought: true }, { text: 'Should be skipped' }],
+        },
+        { role: 'model', parts: [{ text: 'Part 2.' }] },
+      ];
+      // @ts-expect-error Accessing private method for testing purposes
+      chat.recordHistory(userInput, modelOutputMixed);
+      const history = chat.getHistory();
+      expect(history.length).toBe(2);
+      expect(history[0]).toEqual(userInput);
+      expect(history[1].role).toBe('model');
+      expect(history[1].parts).toEqual([{ text: 'Part 1.Part 2.' }]);
+    });
+
+    it('should handle multiple thought parts correctly', () => {
+      const modelOutputMultipleThoughts: Content[] = [
+        { role: 'model', parts: [{ thought: true }] },
+        { role: 'model', parts: [{ text: 'Visible 1' }] },
+        { role: 'model', parts: [{ thought: true }] },
+        { role: 'model', parts: [{ text: 'Visible 2' }] },
+      ];
+      // @ts-expect-error Accessing private method for testing purposes
+      chat.recordHistory(userInput, modelOutputMultipleThoughts);
+      const history = chat.getHistory();
+      expect(history.length).toBe(2);
+      expect(history[0]).toEqual(userInput);
+      expect(history[1].role).toBe('model');
+      expect(history[1].parts).toEqual([{ text: 'Visible 1Visible 2' }]);
+    });
+
+    it('should handle thought part at the end of outputContents', () => {
+      const modelOutputThoughtAtEnd: Content[] = [
+        { role: 'model', parts: [{ text: 'Visible text' }] },
+        { role: 'model', parts: [{ thought: true }] },
+      ];
+      // @ts-expect-error Accessing private method for testing purposes
+      chat.recordHistory(userInput, modelOutputThoughtAtEnd);
+      const history = chat.getHistory();
+      expect(history.length).toBe(2);
+      expect(history[0]).toEqual(userInput);
+      expect(history[1].role).toBe('model');
+      expect(history[1].parts).toEqual([{ text: 'Visible text' }]);
+    });
+  });
+
+  describe('addHistory', () => {
+    it('should add a new content item to the history', () => {
+      const newContent: Content = {
+        role: 'user',
+        parts: [{ text: 'A new message' }],
+      };
+      chat.addHistory(newContent);
+      const history = chat.getHistory();
+      expect(history.length).toBe(1);
+      expect(history[0]).toEqual(newContent);
+    });
+
+    it('should add multiple items correctly', () => {
+      const content1: Content = {
+        role: 'user',
+        parts: [{ text: 'Message 1' }],
+      };
+      const content2: Content = {
+        role: 'model',
+        parts: [{ text: 'Message 2' }],
+      };
+      chat.addHistory(content1);
+      chat.addHistory(content2);
+      const history = chat.getHistory();
+      expect(history.length).toBe(2);
+      expect(history[0]).toEqual(content1);
+      expect(history[1]).toEqual(content2);
+    });
+  });
+
+  describe('sendMessageStream with retries', () => {
+    it('should retry on invalid content, succeed, and report metrics', async () => {
+      // Use mockImplementationOnce to provide a fresh, promise-wrapped generator for each attempt.
+      vi.mocked(mockModelsModule.generateContentStream)
+        .mockImplementationOnce(async () =>
+          // First call returns an invalid stream
+          (async function* () {
+            yield {
+              candidates: [{ content: { parts: [{ text: '' }] } }], // Invalid empty text part
+            } as unknown as GenerateContentResponse;
+          })(),
+        )
+        .mockImplementationOnce(async () =>
+          // Second call returns a valid stream
+          (async function* () {
+            yield {
+              candidates: [
+                { content: { parts: [{ text: 'Successful response' }] } },
+              ],
+            } as unknown as GenerateContentResponse;
+          })(),
+        );
+
+      const stream = await chat.sendMessageStream(
+        { message: 'test' },
+        'prompt-id-retry-success',
+      );
+      const chunks = [];
+      for await (const chunk of stream) {
+        chunks.push(chunk);
+      }
+
+      // Assertions
+      expect(mockLogInvalidChunk).toHaveBeenCalledTimes(1);
+      expect(mockLogContentRetry).toHaveBeenCalledTimes(1);
+      expect(mockLogContentRetryFailure).not.toHaveBeenCalled();
+      expect(mockModelsModule.generateContentStream).toHaveBeenCalledTimes(2);
+      expect(
+        chunks.some(
+          (c) =>
+            c.candidates?.[0]?.content?.parts?.[0]?.text ===
+            'Successful response',
+        ),
+      ).toBe(true);
+
+      // Check that history was recorded correctly once, with no duplicates.
+      const history = chat.getHistory();
+      expect(history.length).toBe(2);
+      expect(history[0]).toEqual({
+        role: 'user',
+        parts: [{ text: 'test' }],
+      });
+      expect(history[1]).toEqual({
+        role: 'model',
+        parts: [{ text: 'Successful response' }],
+      });
+    });
+
+    it('should fail after all retries on persistent invalid content and report metrics', async () => {
+      vi.mocked(mockModelsModule.generateContentStream).mockImplementation(
+        async () =>
+          (async function* () {
+            yield {
+              candidates: [
+                {
+                  content: {
+                    parts: [{ text: '' }],
+                    role: 'model',
+                  },
+                },
+              ],
+            } as unknown as GenerateContentResponse;
+          })(),
+      );
+
+      // This helper function consumes the stream and allows us to test for rejection.
+      async function consumeStreamAndExpectError() {
+        const stream = await chat.sendMessageStream(
+          { message: 'test' },
+          'prompt-id-retry-fail',
+        );
+        for await (const _ of stream) {
+          // Must loop to trigger the internal logic that throws.
+        }
+      }
+
+      await expect(consumeStreamAndExpectError()).rejects.toThrow(
+        EmptyStreamError,
+      );
+
+      // Should be called 3 times (initial + 2 retries)
+      expect(mockModelsModule.generateContentStream).toHaveBeenCalledTimes(3);
+      expect(mockLogInvalidChunk).toHaveBeenCalledTimes(3);
+      expect(mockLogContentRetry).toHaveBeenCalledTimes(2);
+      expect(mockLogContentRetryFailure).toHaveBeenCalledTimes(1);
+
+      // History should be clean, as if the failed turn never happened.
+      const history = chat.getHistory();
+      expect(history.length).toBe(0);
+    });
+  });
+  it('should correctly retry and append to an existing history mid-conversation', async () => {
+    // 1. Setup
+    const initialHistory: Content[] = [
+      { role: 'user', parts: [{ text: 'First question' }] },
+      { role: 'model', parts: [{ text: 'First answer' }] },
+    ];
+    chat.setHistory(initialHistory);
+
+    // 2. Mock the API to fail once with an empty stream, then succeed.
+    vi.mocked(mockModelsModule.generateContentStream)
+      .mockImplementationOnce(async () =>
+        (async function* () {
+          yield {
+            candidates: [{ content: { parts: [{ text: '' }] } }],
+          } as unknown as GenerateContentResponse;
+        })(),
+      )
+      .mockImplementationOnce(async () =>
+        // Second attempt succeeds
+        (async function* () {
+          yield {
+            candidates: [{ content: { parts: [{ text: 'Second answer' }] } }],
+          } as unknown as GenerateContentResponse;
+        })(),
+      );
+
+    // 3. Send a new message
+    const stream = await chat.sendMessageStream(
+      { message: 'Second question' },
+      'prompt-id-retry-existing',
+    );
+    for await (const _ of stream) {
+      // consume stream
+    }
+
+    // 4. Assert the final history and metrics
+    const history = chat.getHistory();
+    expect(history.length).toBe(4);
+
+    // Assert that the correct metrics were reported for one empty-stream retry
+    expect(mockLogContentRetry).toHaveBeenCalledTimes(1);
+
+    // Explicitly verify the structure of each part to satisfy TypeScript
+    const turn1 = history[0];
+    if (!turn1?.parts?.[0] || !('text' in turn1.parts[0])) {
+      throw new Error('Test setup error: First turn is not a valid text part.');
+    }
+    expect(turn1.parts[0].text).toBe('First question');
+
+    const turn2 = history[1];
+    if (!turn2?.parts?.[0] || !('text' in turn2.parts[0])) {
+      throw new Error(
+        'Test setup error: Second turn is not a valid text part.',
+      );
+    }
+    expect(turn2.parts[0].text).toBe('First answer');
+
+    const turn3 = history[2];
+    if (!turn3?.parts?.[0] || !('text' in turn3.parts[0])) {
+      throw new Error('Test setup error: Third turn is not a valid text part.');
+    }
+    expect(turn3.parts[0].text).toBe('Second question');
+
+    const turn4 = history[3];
+    if (!turn4?.parts?.[0] || !('text' in turn4.parts[0])) {
+      throw new Error(
+        'Test setup error: Fourth turn is not a valid text part.',
+      );
+    }
+    expect(turn4.parts[0].text).toBe('Second answer');
+  });
+
+  describe('concurrency control', () => {
+    it('should queue a subsequent sendMessage call until the first one completes', async () => {
+      // 1. Create promises to manually control when the API calls resolve
+      let firstCallResolver: (value: GenerateContentResponse) => void;
+      const firstCallPromise = new Promise<GenerateContentResponse>(
+        (resolve) => {
+          firstCallResolver = resolve;
+        },
+      );
+
+      let secondCallResolver: (value: GenerateContentResponse) => void;
+      const secondCallPromise = new Promise<GenerateContentResponse>(
+        (resolve) => {
+          secondCallResolver = resolve;
+        },
+      );
+
+      // A standard response body for the mock
+      const mockResponse = {
+        candidates: [
+          {
+            content: { parts: [{ text: 'response' }], role: 'model' },
+          },
+        ],
+      } as unknown as GenerateContentResponse;
+
+      // 2. Mock the API to return our controllable promises in order
+      vi.mocked(mockModelsModule.generateContent)
+        .mockReturnValueOnce(firstCallPromise)
+        .mockReturnValueOnce(secondCallPromise);
+
+      // 3. Start the first message call. Do not await it yet.
+      const firstMessagePromise = chat.sendMessage(
+        { message: 'first' },
+        'prompt-1',
+      );
+
+      // Give the event loop a chance to run the async call up to the `await`
+      await new Promise(process.nextTick);
+
+      // 4. While the first call is "in-flight", start the second message call.
+      const secondMessagePromise = chat.sendMessage(
+        { message: 'second' },
+        'prompt-2',
+      );
+
+      // 5. CRUCIAL CHECK: At this point, only the first API call should have been made.
+      // The second call should be waiting on `sendPromise`.
+      expect(mockModelsModule.generateContent).toHaveBeenCalledTimes(1);
+      expect(mockModelsModule.generateContent).toHaveBeenCalledWith(
+        expect.objectContaining({
+          contents: expect.arrayContaining([
+            expect.objectContaining({ parts: [{ text: 'first' }] }),
+          ]),
+        }),
+        'prompt-1',
+      );
+
+      // 6. Unblock the first API call and wait for the first message to fully complete.
+      firstCallResolver!(mockResponse);
+      await firstMessagePromise;
+
+      // Give the event loop a chance to unblock and run the second call.
+      await new Promise(process.nextTick);
+
+      // 7. CRUCIAL CHECK: Now, the second API call should have been made.
+      expect(mockModelsModule.generateContent).toHaveBeenCalledTimes(2);
+      expect(mockModelsModule.generateContent).toHaveBeenCalledWith(
+        expect.objectContaining({
+          contents: expect.arrayContaining([
+            expect.objectContaining({ parts: [{ text: 'second' }] }),
+          ]),
+        }),
+        'prompt-2',
+      );
+
+      // 8. Clean up by resolving the second call.
+      secondCallResolver!(mockResponse);
+      await secondMessagePromise;
+    });
+  });
+  it('should retry if the model returns a completely empty stream (no chunks)', async () => {
+    // 1. Mock the API to return an empty stream first, then a valid one.
+    vi.mocked(mockModelsModule.generateContentStream)
+      .mockImplementationOnce(
+        // First call resolves to an async generator that yields nothing.
+        async () => (async function* () {})(),
+      )
+      .mockImplementationOnce(
+        // Second call returns a valid stream.
+        async () =>
+          (async function* () {
+            yield {
+              candidates: [
+                {
+                  content: {
+                    parts: [{ text: 'Successful response after empty' }],
+                  },
+                },
+              ],
+            } as unknown as GenerateContentResponse;
+          })(),
+      );
+
+    // 2. Call the method and consume the stream.
+    const stream = await chat.sendMessageStream(
+      { message: 'test empty stream' },
+      'prompt-id-empty-stream',
+    );
+    const chunks = [];
+    for await (const chunk of stream) {
+      chunks.push(chunk);
+    }
+
+    // 3. Assert the results.
+    expect(mockModelsModule.generateContentStream).toHaveBeenCalledTimes(2);
+    expect(
+      chunks.some(
+        (c) =>
+          c.candidates?.[0]?.content?.parts?.[0]?.text ===
+          'Successful response after empty',
+      ),
+    ).toBe(true);
+
+    const history = chat.getHistory();
+    expect(history.length).toBe(2);
+
+    // Explicitly verify the structure of each part to satisfy TypeScript
+    const turn1 = history[0];
+    if (!turn1?.parts?.[0] || !('text' in turn1.parts[0])) {
+      throw new Error('Test setup error: First turn is not a valid text part.');
+    }
+    expect(turn1.parts[0].text).toBe('test empty stream');
+
+    const turn2 = history[1];
+    if (!turn2?.parts?.[0] || !('text' in turn2.parts[0])) {
+      throw new Error(
+        'Test setup error: Second turn is not a valid text part.',
+      );
+    }
+    expect(turn2.parts[0].text).toBe('Successful response after empty');
+  });
+  it('should queue a subsequent sendMessageStream call until the first stream is fully consumed', async () => {
+    // 1. Create a promise to manually control the stream's lifecycle
+    let continueFirstStream: () => void;
+    const firstStreamContinuePromise = new Promise<void>((resolve) => {
+      continueFirstStream = resolve;
+    });
+
+    // 2. Mock the API to return controllable async generators
+    const firstStreamGenerator = (async function* () {
+      yield {
+        candidates: [
+          { content: { parts: [{ text: 'first response part 1' }] } },
+        ],
+      } as unknown as GenerateContentResponse;
+      await firstStreamContinuePromise; // Pause the stream
+      yield {
+        candidates: [{ content: { parts: [{ text: ' part 2' }] } }],
+      } as unknown as GenerateContentResponse;
+    })();
+
+    const secondStreamGenerator = (async function* () {
+      yield {
+        candidates: [{ content: { parts: [{ text: 'second response' }] } }],
+      } as unknown as GenerateContentResponse;
+    })();
+
+    vi.mocked(mockModelsModule.generateContentStream)
+      .mockResolvedValueOnce(firstStreamGenerator)
+      .mockResolvedValueOnce(secondStreamGenerator);
+
+    // 3. Start the first stream and consume only the first chunk to pause it
+    const firstStream = await chat.sendMessageStream(
+      { message: 'first' },
+      'prompt-1',
+    );
+    const firstStreamIterator = firstStream[Symbol.asyncIterator]();
+    await firstStreamIterator.next();
+
+    // 4. While the first stream is paused, start the second call. It will block.
+    const secondStreamPromise = chat.sendMessageStream(
+      { message: 'second' },
+      'prompt-2',
+    );
+
+    // 5. Assert that only one API call has been made so far.
+    expect(mockModelsModule.generateContentStream).toHaveBeenCalledTimes(1);
+
+    // 6. Unblock and fully consume the first stream to completion.
+    continueFirstStream!();
+    await firstStreamIterator.next(); // Consume the rest of the stream
+    await firstStreamIterator.next(); // Finish the iterator
+
+    // 7. Now that the first stream is done, await the second promise to get its generator.
+    const secondStream = await secondStreamPromise;
+
+    // 8. Start consuming the second stream, which triggers its internal API call.
+    const secondStreamIterator = secondStream[Symbol.asyncIterator]();
+    await secondStreamIterator.next();
+
+    // 9. The second API call should now have been made.
+    expect(mockModelsModule.generateContentStream).toHaveBeenCalledTimes(2);
+
+    // 10. FIX: Fully consume the second stream to ensure recordHistory is called.
+    await secondStreamIterator.next(); // This finishes the iterator.
+
+    // 11. Final check on history.
+    const history = chat.getHistory();
+    expect(history.length).toBe(4);
+
+    const turn4 = history[3];
+    if (!turn4?.parts?.[0] || !('text' in turn4.parts[0])) {
+      throw new Error(
+        'Test setup error: Fourth turn is not a valid text part.',
+      );
+    }
+    expect(turn4.parts[0].text).toBe('second response');
+  });
+});