Add files using upload-large-folder tool

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

@@ -0,0 +1,763 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+// DISCLAIMER: This is a copied version of https://github.com/googleapis/js-genai/blob/main/src/chats.ts with the intention of working around a key bug
+// where function responses are not treated as "valid" responses: https://b.corp.google.com/issues/420354090
+
+import {
+  GenerateContentResponse,
+  Content,
+  GenerateContentConfig,
+  SendMessageParameters,
+  createUserContent,
+  Part,
+  Tool,
+} from '@google/genai';
+import { retryWithBackoff } from '../utils/retry.js';
+import { isFunctionResponse } from '../utils/messageInspectors.js';
+import { ContentGenerator, AuthType } from './contentGenerator.js';
+import { Config } from '../config/config.js';
+import { DEFAULT_GEMINI_FLASH_MODEL } from '../config/models.js';
+import { hasCycleInSchema } from '../tools/tools.js';
+import { StructuredError } from './turn.js';
+import {
+  logContentRetry,
+  logContentRetryFailure,
+  logInvalidChunk,
+} from '../telemetry/loggers.js';
+import {
+  ContentRetryEvent,
+  ContentRetryFailureEvent,
+  InvalidChunkEvent,
+} from '../telemetry/types.js';
+
+/**
+ * Options for retrying due to invalid content from the model.
+ */
+interface ContentRetryOptions {
+  /** Total number of attempts to make (1 initial + N retries). */
+  maxAttempts: number;
+  /** The base delay in milliseconds for linear backoff. */
+  initialDelayMs: number;
+}
+
+const INVALID_CONTENT_RETRY_OPTIONS: ContentRetryOptions = {
+  maxAttempts: 3, // 1 initial call + 2 retries
+  initialDelayMs: 500,
+};
+/**
+ * Returns true if the response is valid, false otherwise.
+ */
+function isValidResponse(response: GenerateContentResponse): boolean {
+  // The Dashscope provider returns empty content with usage metadata at the end of the stream
+  if (response.usageMetadata) {
+    return true;
+  }
+
+  if (response.candidates === undefined || response.candidates.length === 0) {
+    return false;
+  }
+
+  const content = response.candidates[0]?.content;
+  return content !== undefined && isValidContent(content);
+}
+
+function isValidContent(content: Content): boolean {
+  if (content.parts === undefined || content.parts.length === 0) {
+    return false;
+  }
+  for (const part of content.parts) {
+    if (part === undefined || Object.keys(part).length === 0) {
+      return false;
+    }
+    if (
+      !part.thought &&
+      part.text !== undefined &&
+      part.text === '' &&
+      part.functionCall === undefined
+    ) {
+      return false;
+    }
+  }
+  return true;
+}
+
+/**
+ * Validates the history contains the correct roles.
+ *
+ * @throws Error if the history does not start with a user turn.
+ * @throws Error if the history contains an invalid role.
+ */
+function validateHistory(history: Content[]) {
+  for (const content of history) {
+    if (content.role !== 'user' && content.role !== 'model') {
+      throw new Error(`Role must be user or model, but got ${content.role}.`);
+    }
+  }
+}
+
+/**
+ * Extracts the curated (valid) history from a comprehensive history.
+ *
+ * @remarks
+ * The model may sometimes generate invalid or empty contents(e.g., due to safety
+ * filters or recitation). Extracting valid turns from the history
+ * ensures that subsequent requests could be accepted by the model.
+ */
+function extractCuratedHistory(comprehensiveHistory: Content[]): Content[] {
+  if (comprehensiveHistory === undefined || comprehensiveHistory.length === 0) {
+    return [];
+  }
+  const curatedHistory: Content[] = [];
+  const length = comprehensiveHistory.length;
+  let i = 0;
+  while (i < length) {
+    if (comprehensiveHistory[i].role === 'user') {
+      curatedHistory.push(comprehensiveHistory[i]);
+      i++;
+    } else {
+      const modelOutput: Content[] = [];
+      let isValid = true;
+      while (i < length && comprehensiveHistory[i].role === 'model') {
+        modelOutput.push(comprehensiveHistory[i]);
+        if (isValid && !isValidContent(comprehensiveHistory[i])) {
+          isValid = false;
+        }
+        i++;
+      }
+      if (isValid) {
+        curatedHistory.push(...modelOutput);
+      }
+    }
+  }
+  return curatedHistory;
+}
+
+/**
+ * Custom error to signal that a stream completed without valid content,
+ * which should trigger a retry.
+ */
+export class EmptyStreamError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = 'EmptyStreamError';
+  }
+}
+
+/**
+ * Chat session that enables sending messages to the model with previous
+ * conversation context.
+ *
+ * @remarks
+ * The session maintains all the turns between user and model.
+ */
+export class GeminiChat {
+  // A promise to represent the current state of the message being sent to the
+  // model.
+  private sendPromise: Promise<void> = Promise.resolve();
+
+  constructor(
+    private readonly config: Config,
+    private readonly contentGenerator: ContentGenerator,
+    private readonly generationConfig: GenerateContentConfig = {},
+    private history: Content[] = [],
+  ) {
+    validateHistory(history);
+  }
+
+  /**
+   * 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;
+  }
+
+  setSystemInstruction(sysInstr: string) {
+    this.generationConfig.systemInstruction = sysInstr;
+  }
+  /**
+   * Sends a message to the model and returns the response.
+   *
+   * @remarks
+   * This method will wait for the previous message to be processed before
+   * sending the next message.
+   *
+   * @see {@link Chat#sendMessageStream} for streaming method.
+   * @param params - parameters for sending messages within a chat session.
+   * @returns The model's response.
+   *
+   * @example
+   * ```ts
+   * const chat = ai.chats.create({model: 'gemini-2.0-flash'});
+   * const response = await chat.sendMessage({
+   *   message: 'Why is the sky blue?'
+   * });
+   * console.log(response.text);
+   * ```
+   */
+  async sendMessage(
+    params: SendMessageParameters,
+    prompt_id: string,
+  ): Promise<GenerateContentResponse> {
+    await this.sendPromise;
+    const userContent = createUserContent(params.message);
+    const requestContents = this.getHistory(true).concat(userContent);
+
+    let response: GenerateContentResponse;
+
+    try {
+      const apiCall = () => {
+        const modelToUse = this.config.getModel() || DEFAULT_GEMINI_FLASH_MODEL;
+
+        // Prevent Flash model calls immediately after quota error
+        if (
+          this.config.getQuotaErrorOccurred() &&
+          modelToUse === DEFAULT_GEMINI_FLASH_MODEL
+        ) {
+          throw new Error(
+            'Please submit a new query to continue with the Flash model.',
+          );
+        }
+
+        return this.contentGenerator.generateContent(
+          {
+            model: modelToUse,
+            contents: requestContents,
+            config: { ...this.generationConfig, ...params.config },
+          },
+          prompt_id,
+        );
+      };
+
+      response = await retryWithBackoff(apiCall, {
+        shouldRetry: (error: unknown) => {
+          // Check for known error messages and codes.
+          if (error instanceof Error && error.message) {
+            if (isSchemaDepthError(error.message)) return false;
+            if (error.message.includes('429')) return true;
+            if (error.message.match(/5\d{2}/)) return true;
+          }
+          return false; // Don't retry other errors by default
+        },
+        onPersistent429: async (authType?: string, error?: unknown) =>
+          await this.handleFlashFallback(authType, error),
+        authType: this.config.getContentGeneratorConfig()?.authType,
+      });
+
+      this.sendPromise = (async () => {
+        const outputContent = response.candidates?.[0]?.content;
+        // Because the AFC input contains the entire curated chat history in
+        // addition to the new user input, we need to truncate the AFC history
+        // to deduplicate the existing chat history.
+        const fullAutomaticFunctionCallingHistory =
+          response.automaticFunctionCallingHistory;
+        const index = this.getHistory(true).length;
+        let automaticFunctionCallingHistory: Content[] = [];
+        if (fullAutomaticFunctionCallingHistory != null) {
+          automaticFunctionCallingHistory =
+            fullAutomaticFunctionCallingHistory.slice(index) ?? [];
+        }
+        const modelOutput = outputContent ? [outputContent] : [];
+        this.recordHistory(
+          userContent,
+          modelOutput,
+          automaticFunctionCallingHistory,
+        );
+      })();
+      await this.sendPromise.catch(() => {
+        // Resets sendPromise to avoid subsequent calls failing
+        this.sendPromise = Promise.resolve();
+      });
+      return response;
+    } catch (error) {
+      this.sendPromise = Promise.resolve();
+      throw error;
+    }
+  }
+
+  /**
+   * Sends a message to the model and returns the response in chunks.
+   *
+   * @remarks
+   * This method will wait for the previous message to be processed before
+   * sending the next message.
+   *
+   * @see {@link Chat#sendMessage} for non-streaming method.
+   * @param params - parameters for sending the message.
+   * @return The model's response.
+   *
+   * @example
+   * ```ts
+   * const chat = ai.chats.create({model: 'gemini-2.0-flash'});
+   * const response = await chat.sendMessageStream({
+   *   message: 'Why is the sky blue?'
+   * });
+   * for await (const chunk of response) {
+   *   console.log(chunk.text);
+   * }
+   * ```
+   */
+  async sendMessageStream(
+    params: SendMessageParameters,
+    prompt_id: string,
+  ): Promise<AsyncGenerator<GenerateContentResponse>> {
+    await this.sendPromise;
+
+    let streamDoneResolver: () => void;
+    const streamDonePromise = new Promise<void>((resolve) => {
+      streamDoneResolver = resolve;
+    });
+    this.sendPromise = streamDonePromise;
+
+    const userContent = createUserContent(params.message);
+
+    // Add user content to history ONCE before any attempts.
+    this.history.push(userContent);
+    const requestContents = this.getHistory(true);
+
+    // eslint-disable-next-line @typescript-eslint/no-this-alias
+    const self = this;
+    return (async function* () {
+      try {
+        let lastError: unknown = new Error('Request failed after all retries.');
+
+        for (
+          let attempt = 0;
+          attempt < INVALID_CONTENT_RETRY_OPTIONS.maxAttempts;
+          attempt++
+        ) {
+          try {
+            const stream = await self.makeApiCallAndProcessStream(
+              requestContents,
+              params,
+              prompt_id,
+              userContent,
+            );
+
+            for await (const chunk of stream) {
+              yield chunk;
+            }
+
+            lastError = null;
+            break;
+          } catch (error) {
+            lastError = error;
+            const isContentError = error instanceof EmptyStreamError;
+
+            if (isContentError) {
+              // Check if we have more attempts left.
+              if (attempt < INVALID_CONTENT_RETRY_OPTIONS.maxAttempts - 1) {
+                logContentRetry(
+                  self.config,
+                  new ContentRetryEvent(
+                    attempt,
+                    'EmptyStreamError',
+                    INVALID_CONTENT_RETRY_OPTIONS.initialDelayMs,
+                  ),
+                );
+                await new Promise((res) =>
+                  setTimeout(
+                    res,
+                    INVALID_CONTENT_RETRY_OPTIONS.initialDelayMs *
+                      (attempt + 1),
+                  ),
+                );
+                continue;
+              }
+            }
+            break;
+          }
+        }
+
+        if (lastError) {
+          if (lastError instanceof EmptyStreamError) {
+            logContentRetryFailure(
+              self.config,
+              new ContentRetryFailureEvent(
+                INVALID_CONTENT_RETRY_OPTIONS.maxAttempts,
+                'EmptyStreamError',
+              ),
+            );
+          }
+          // If the stream fails, remove the user message that was added.
+          if (self.history[self.history.length - 1] === userContent) {
+            self.history.pop();
+          }
+          throw lastError;
+        }
+      } finally {
+        streamDoneResolver!();
+      }
+    })();
+  }
+
+  private async makeApiCallAndProcessStream(
+    requestContents: Content[],
+    params: SendMessageParameters,
+    prompt_id: string,
+    userContent: Content,
+  ): Promise<AsyncGenerator<GenerateContentResponse>> {
+    const apiCall = () => {
+      const modelToUse = this.config.getModel();
+
+      if (
+        this.config.getQuotaErrorOccurred() &&
+        modelToUse === DEFAULT_GEMINI_FLASH_MODEL
+      ) {
+        throw new Error(
+          'Please submit a new query to continue with the Flash model.',
+        );
+      }
+
+      return this.contentGenerator.generateContentStream(
+        {
+          model: modelToUse,
+          contents: requestContents,
+          config: { ...this.generationConfig, ...params.config },
+        },
+        prompt_id,
+      );
+    };
+
+    const streamResponse = await retryWithBackoff(apiCall, {
+      shouldRetry: (error: unknown) => {
+        if (error instanceof Error && error.message) {
+          if (isSchemaDepthError(error.message)) return false;
+          if (error.message.includes('429')) return true;
+          if (error.message.match(/5\d{2}/)) return true;
+        }
+        return false;
+      },
+      onPersistent429: async (authType?: string, error?: unknown) =>
+        await this.handleFlashFallback(authType, error),
+      authType: this.config.getContentGeneratorConfig()?.authType,
+    });
+
+    return this.processStreamResponse(streamResponse, userContent);
+  }
+
+  /**
+   * Returns the chat history.
+   *
+   * @remarks
+   * The history is a list of contents alternating between user and model.
+   *
+   * There are two types of history:
+   * - The `curated history` contains only the valid turns between user and
+   * model, which will be included in the subsequent requests sent to the model.
+   * - The `comprehensive history` contains all turns, including invalid or
+   *   empty model outputs, providing a complete record of the history.
+   *
+   * The history is updated after receiving the response from the model,
+   * for streaming response, it means receiving the last chunk of the response.
+   *
+   * The `comprehensive history` is returned by default. To get the `curated
+   * history`, set the `curated` parameter to `true`.
+   *
+   * @param curated - whether to return the curated history or the comprehensive
+   *     history.
+   * @return History contents alternating between user and model for the entire
+   *     chat session.
+   */
+  getHistory(curated: boolean = false): Content[] {
+    const history = curated
+      ? extractCuratedHistory(this.history)
+      : this.history;
+    // Deep copy the history to avoid mutating the history outside of the
+    // chat session.
+    return structuredClone(history);
+  }
+
+  /**
+   * Clears the chat history.
+   */
+  clearHistory(): void {
+    this.history = [];
+  }
+
+  /**
+   * Adds a new entry to the chat history.
+   */
+  addHistory(content: Content): void {
+    this.history.push(content);
+  }
+  setHistory(history: Content[]): void {
+    this.history = history;
+  }
+
+  setTools(tools: Tool[]): void {
+    this.generationConfig.tools = tools;
+  }
+
+  async maybeIncludeSchemaDepthContext(error: StructuredError): Promise<void> {
+    // Check for potentially problematic cyclic tools with cyclic schemas
+    // and include a recommendation to remove potentially problematic tools.
+    if (
+      isSchemaDepthError(error.message) ||
+      isInvalidArgumentError(error.message)
+    ) {
+      const tools = this.config.getToolRegistry().getAllTools();
+      const cyclicSchemaTools: string[] = [];
+      for (const tool of tools) {
+        if (
+          (tool.schema.parametersJsonSchema &&
+            hasCycleInSchema(tool.schema.parametersJsonSchema)) ||
+          (tool.schema.parameters && hasCycleInSchema(tool.schema.parameters))
+        ) {
+          cyclicSchemaTools.push(tool.displayName);
+        }
+      }
+      if (cyclicSchemaTools.length > 0) {
+        const extraDetails =
+          `\n\nThis error was probably caused by cyclic schema references in one of the following tools, try disabling them with excludeTools:\n\n - ` +
+          cyclicSchemaTools.join(`\n - `) +
+          `\n`;
+        error.message += extraDetails;
+      }
+    }
+  }
+
+  private async *processStreamResponse(
+    streamResponse: AsyncGenerator<GenerateContentResponse>,
+    userInput: Content,
+  ): AsyncGenerator<GenerateContentResponse> {
+    const modelResponseParts: Part[] = [];
+    let isStreamInvalid = false;
+    let hasReceivedAnyChunk = false;
+
+    for await (const chunk of streamResponse) {
+      hasReceivedAnyChunk = true;
+      if (isValidResponse(chunk)) {
+        const content = chunk.candidates?.[0]?.content;
+        if (content) {
+          // Filter out thought parts from being added to history.
+          if (!this.isThoughtContent(content) && content.parts) {
+            modelResponseParts.push(...content.parts);
+          }
+        }
+      } else {
+        logInvalidChunk(
+          this.config,
+          new InvalidChunkEvent('Invalid chunk received from stream.'),
+        );
+        isStreamInvalid = true;
+      }
+      yield chunk; // Yield every chunk to the UI immediately.
+    }
+
+    // Now that the stream is finished, make a decision.
+    // Throw an error if the stream was invalid OR if it was completely empty.
+    if (isStreamInvalid || !hasReceivedAnyChunk) {
+      throw new EmptyStreamError(
+        'Model stream was invalid or completed without valid content.',
+      );
+    }
+
+    // Use recordHistory to correctly save the conversation turn.
+    const modelOutput: Content[] = [
+      { role: 'model', parts: modelResponseParts },
+    ];
+    this.recordHistory(userInput, modelOutput);
+  }
+
+  private recordHistory(
+    userInput: Content,
+    modelOutput: Content[],
+    automaticFunctionCallingHistory?: Content[],
+  ) {
+    const newHistoryEntries: Content[] = [];
+
+    // Part 1: Handle the user's part of the turn.
+    if (
+      automaticFunctionCallingHistory &&
+      automaticFunctionCallingHistory.length > 0
+    ) {
+      newHistoryEntries.push(
+        ...extractCuratedHistory(automaticFunctionCallingHistory),
+      );
+    } else {
+      // Guard for streaming calls where the user input might already be in the history.
+      if (
+        this.history.length === 0 ||
+        this.history[this.history.length - 1] !== userInput
+      ) {
+        newHistoryEntries.push(userInput);
+      }
+    }
+
+    // Part 2: Handle the model's part of the turn, filtering out thoughts.
+    const nonThoughtModelOutput = modelOutput.filter(
+      (content) => !this.isThoughtContent(content),
+    );
+
+    let outputContents: Content[] = [];
+    if (nonThoughtModelOutput.length > 0) {
+      outputContents = nonThoughtModelOutput;
+    } else if (
+      modelOutput.length === 0 &&
+      !isFunctionResponse(userInput) &&
+      !automaticFunctionCallingHistory
+    ) {
+      // Add an empty model response if the model truly returned nothing.
+      outputContents.push({ role: 'model', parts: [] } as Content);
+    }
+
+    // Part 3: Consolidate the parts of this turn's model response.
+    const consolidatedOutputContents: Content[] = [];
+    if (outputContents.length > 0) {
+      for (const content of outputContents) {
+        const lastContent =
+          consolidatedOutputContents[consolidatedOutputContents.length - 1];
+        if (this.hasTextContent(lastContent) && this.hasTextContent(content)) {
+          lastContent.parts[0].text += content.parts[0].text || '';
+          if (content.parts.length > 1) {
+            lastContent.parts.push(...content.parts.slice(1));
+          }
+        } else {
+          consolidatedOutputContents.push(content);
+        }
+      }
+    }
+
+    // Part 4: Add the new turn (user and model parts) to the main history.
+    this.history.push(...newHistoryEntries, ...consolidatedOutputContents);
+  }
+
+  private hasTextContent(
+    content: Content | undefined,
+  ): content is Content & { parts: [{ text: string }, ...Part[]] } {
+    return !!(
+      content &&
+      content.role === 'model' &&
+      content.parts &&
+      content.parts.length > 0 &&
+      typeof content.parts[0].text === 'string' &&
+      content.parts[0].text !== ''
+    );
+  }
+
+  private isThoughtContent(
+    content: Content | undefined,
+  ): content is Content & { parts: [{ thought: boolean }, ...Part[]] } {
+    return !!(
+      content &&
+      content.role === 'model' &&
+      content.parts &&
+      content.parts.length > 0 &&
+      typeof content.parts[0].thought === 'boolean' &&
+      content.parts[0].thought === true
+    );
+  }
+
+  /**
+   * 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;
+  }
+}
+
+/** Visible for Testing */
+export function isSchemaDepthError(errorMessage: string): boolean {
+  return errorMessage.includes('maximum schema depth exceeded');
+}
+
+export function isInvalidArgumentError(errorMessage: string): boolean {
+  return errorMessage.includes('Request contains an invalid argument');
+}

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

@@ -0,0 +1,85 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { describe, it, expect } from 'vitest';
+import { partListUnionToString } from './geminiRequest.js';
+import { type Part } from '@google/genai';
+
+describe('partListUnionToString', () => {
+  it('should return the string value if the input is a string', () => {
+    const result = partListUnionToString('hello');
+    expect(result).toBe('hello');
+  });
+
+  it('should return a concatenated string if the input is an array of strings', () => {
+    const result = partListUnionToString(['hello', ' ', 'world']);
+    expect(result).toBe('hello world');
+  });
+
+  it('should handle videoMetadata', () => {
+    const part: Part = { videoMetadata: {} };
+    const result = partListUnionToString(part);
+    expect(result).toBe('[Video Metadata]');
+  });
+
+  it('should handle thought', () => {
+    const part: Part = { thought: true };
+    const result = partListUnionToString(part);
+    expect(result).toBe('[Thought: true]');
+  });
+
+  it('should handle codeExecutionResult', () => {
+    const part: Part = { codeExecutionResult: {} };
+    const result = partListUnionToString(part);
+    expect(result).toBe('[Code Execution Result]');
+  });
+
+  it('should handle executableCode', () => {
+    const part: Part = { executableCode: {} };
+    const result = partListUnionToString(part);
+    expect(result).toBe('[Executable Code]');
+  });
+
+  it('should handle fileData', () => {
+    const part: Part = {
+      fileData: { mimeType: 'text/plain', fileUri: 'file.txt' },
+    };
+    const result = partListUnionToString(part);
+    expect(result).toBe('[File Data]');
+  });
+
+  it('should handle functionCall', () => {
+    const part: Part = { functionCall: { name: 'myFunction' } };
+    const result = partListUnionToString(part);
+    expect(result).toBe('[Function Call: myFunction]');
+  });
+
+  it('should handle functionResponse', () => {
+    const part: Part = {
+      functionResponse: { name: 'myFunction', response: {} },
+    };
+    const result = partListUnionToString(part);
+    expect(result).toBe('[Function Response: myFunction]');
+  });
+
+  it('should handle inlineData', () => {
+    const part: Part = { inlineData: { mimeType: 'image/png', data: '...' } };
+    const result = partListUnionToString(part);
+    expect(result).toBe('<image/png>');
+  });
+
+  it('should handle text', () => {
+    const part: Part = { text: 'hello' };
+    const result = partListUnionToString(part);
+    expect(result).toBe('hello');
+  });
+
+  it('should return an empty string for an unknown part type', () => {
+    const part: Part = {};
+    const result = partListUnionToString(part);
+    expect(result).toBe('');
+  });
+});

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

@@ -0,0 +1,19 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { type PartListUnion } from '@google/genai';
+import { partToString } from '../utils/partUtils.js';
+
+/**
+ * Represents a request to be sent to the Gemini API.
+ * For now, it's an alias to PartListUnion as the primary content.
+ * This can be expanded later to include other request parameters.
+ */
+export type GeminiCodeRequest = PartListUnion;
+
+export function partListUnionToString(value: PartListUnion): string {
+  return partToString(value, { verbose: true });
+}

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

@@ -0,0 +1,727 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import {
+  describe,
+  it,
+  expect,
+  vi,
+  beforeEach,
+  afterEach,
+  afterAll,
+} from 'vitest';
+import {
+  Logger,
+  MessageSenderType,
+  LogEntry,
+  encodeTagName,
+  decodeTagName,
+} from './logger.js';
+import { promises as fs, existsSync } from 'node:fs';
+import path from 'node:path';
+import { Content } from '@google/genai';
+
+import crypto from 'node:crypto';
+import os from 'node:os';
+
+const GEMINI_DIR_NAME = '.qwen';
+const TMP_DIR_NAME = 'tmp';
+const LOG_FILE_NAME = 'logs.json';
+const CHECKPOINT_FILE_NAME = 'checkpoint.json';
+
+const projectDir = process.cwd();
+const hash = crypto.createHash('sha256').update(projectDir).digest('hex');
+const TEST_GEMINI_DIR = path.join(
+  os.homedir(),
+  GEMINI_DIR_NAME,
+  TMP_DIR_NAME,
+  hash,
+);
+
+const TEST_LOG_FILE_PATH = path.join(TEST_GEMINI_DIR, LOG_FILE_NAME);
+const TEST_CHECKPOINT_FILE_PATH = path.join(
+  TEST_GEMINI_DIR,
+  CHECKPOINT_FILE_NAME,
+);
+
+async function cleanupLogAndCheckpointFiles() {
+  try {
+    await fs.rm(TEST_GEMINI_DIR, { recursive: true, force: true });
+  } catch (_error) {
+    // Ignore errors, as the directory may not exist, which is fine.
+  }
+}
+
+async function readLogFile(): Promise<LogEntry[]> {
+  try {
+    const content = await fs.readFile(TEST_LOG_FILE_PATH, 'utf-8');
+    return JSON.parse(content) as LogEntry[];
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === 'ENOENT') {
+      return [];
+    }
+    throw error;
+  }
+}
+
+vi.mock('../utils/session.js', () => ({
+  sessionId: 'test-session-id',
+}));
+
+describe('Logger', () => {
+  let logger: Logger;
+  const testSessionId = 'test-session-id';
+
+  beforeEach(async () => {
+    vi.resetAllMocks();
+    vi.useFakeTimers();
+    vi.setSystemTime(new Date('2025-01-01T12:00:00.000Z'));
+    // Clean up before the test
+    await cleanupLogAndCheckpointFiles();
+    // Ensure the directory exists for the test
+    await fs.mkdir(TEST_GEMINI_DIR, { recursive: true });
+    logger = new Logger(testSessionId);
+    await logger.initialize();
+  });
+
+  afterEach(async () => {
+    if (logger) {
+      logger.close();
+    }
+    // Clean up after the test
+    await cleanupLogAndCheckpointFiles();
+    vi.useRealTimers();
+    vi.restoreAllMocks();
+  });
+
+  afterAll(async () => {
+    // Final cleanup
+    await cleanupLogAndCheckpointFiles();
+  });
+
+  describe('initialize', () => {
+    it('should create .gemini directory and an empty log file if none exist', async () => {
+      const dirExists = await fs
+        .access(TEST_GEMINI_DIR)
+        .then(() => true)
+        .catch(() => false);
+      expect(dirExists).toBe(true);
+
+      const fileExists = await fs
+        .access(TEST_LOG_FILE_PATH)
+        .then(() => true)
+        .catch(() => false);
+      expect(fileExists).toBe(true);
+
+      const logContent = await readLogFile();
+      expect(logContent).toEqual([]);
+    });
+
+    it('should load existing logs and set correct messageId for the current session', async () => {
+      const currentSessionId = 'session-123';
+      const anotherSessionId = 'session-456';
+      const existingLogs: LogEntry[] = [
+        {
+          sessionId: currentSessionId,
+          messageId: 0,
+          timestamp: new Date('2025-01-01T10:00:05.000Z').toISOString(),
+          type: MessageSenderType.USER,
+          message: 'Msg1',
+        },
+        {
+          sessionId: anotherSessionId,
+          messageId: 5,
+          timestamp: new Date('2025-01-01T09:00:00.000Z').toISOString(),
+          type: MessageSenderType.USER,
+          message: 'OldMsg',
+        },
+        {
+          sessionId: currentSessionId,
+          messageId: 1,
+          timestamp: new Date('2025-01-01T10:00:10.000Z').toISOString(),
+          type: MessageSenderType.USER,
+          message: 'Msg2',
+        },
+      ];
+      await fs.writeFile(
+        TEST_LOG_FILE_PATH,
+        JSON.stringify(existingLogs, null, 2),
+      );
+      const newLogger = new Logger(currentSessionId);
+      await newLogger.initialize();
+      expect(newLogger['messageId']).toBe(2);
+      expect(newLogger['logs']).toEqual(existingLogs);
+      newLogger.close();
+    });
+
+    it('should set messageId to 0 for a new session if log file exists but has no logs for current session', async () => {
+      const existingLogs: LogEntry[] = [
+        {
+          sessionId: 'some-other-session',
+          messageId: 5,
+          timestamp: new Date().toISOString(),
+          type: MessageSenderType.USER,
+          message: 'OldMsg',
+        },
+      ];
+      await fs.writeFile(
+        TEST_LOG_FILE_PATH,
+        JSON.stringify(existingLogs, null, 2),
+      );
+      const newLogger = new Logger('a-new-session');
+      await newLogger.initialize();
+      expect(newLogger['messageId']).toBe(0);
+      newLogger.close();
+    });
+
+    it('should be idempotent', async () => {
+      await logger.logMessage(MessageSenderType.USER, 'test message');
+      const initialMessageId = logger['messageId'];
+      const initialLogCount = logger['logs'].length;
+
+      await logger.initialize(); // Second call should not change state
+
+      expect(logger['messageId']).toBe(initialMessageId);
+      expect(logger['logs'].length).toBe(initialLogCount);
+      const logsFromFile = await readLogFile();
+      expect(logsFromFile.length).toBe(1);
+    });
+
+    it('should handle invalid JSON in log file by backing it up and starting fresh', async () => {
+      await fs.writeFile(TEST_LOG_FILE_PATH, 'invalid json');
+      const consoleDebugSpy = vi
+        .spyOn(console, 'debug')
+        .mockImplementation(() => {});
+
+      const newLogger = new Logger(testSessionId);
+      await newLogger.initialize();
+
+      expect(consoleDebugSpy).toHaveBeenCalledWith(
+        expect.stringContaining('Invalid JSON in log file'),
+        expect.any(SyntaxError),
+      );
+      const logContent = await readLogFile();
+      expect(logContent).toEqual([]);
+      const dirContents = await fs.readdir(TEST_GEMINI_DIR);
+      expect(
+        dirContents.some(
+          (f) =>
+            f.startsWith(LOG_FILE_NAME + '.invalid_json') && f.endsWith('.bak'),
+        ),
+      ).toBe(true);
+      newLogger.close();
+    });
+
+    it('should handle non-array JSON in log file by backing it up and starting fresh', async () => {
+      await fs.writeFile(
+        TEST_LOG_FILE_PATH,
+        JSON.stringify({ not: 'an array' }),
+      );
+      const consoleDebugSpy = vi
+        .spyOn(console, 'debug')
+        .mockImplementation(() => {});
+
+      const newLogger = new Logger(testSessionId);
+      await newLogger.initialize();
+
+      expect(consoleDebugSpy).toHaveBeenCalledWith(
+        `Log file at ${TEST_LOG_FILE_PATH} is not a valid JSON array. Starting with empty logs.`,
+      );
+      const logContent = await readLogFile();
+      expect(logContent).toEqual([]);
+      const dirContents = await fs.readdir(TEST_GEMINI_DIR);
+      expect(
+        dirContents.some(
+          (f) =>
+            f.startsWith(LOG_FILE_NAME + '.malformed_array') &&
+            f.endsWith('.bak'),
+        ),
+      ).toBe(true);
+      newLogger.close();
+    });
+  });
+
+  describe('logMessage', () => {
+    it('should append a message to the log file and update in-memory logs', async () => {
+      await logger.logMessage(MessageSenderType.USER, 'Hello, world!');
+      const logsFromFile = await readLogFile();
+      expect(logsFromFile.length).toBe(1);
+      expect(logsFromFile[0]).toMatchObject({
+        sessionId: testSessionId,
+        messageId: 0,
+        type: MessageSenderType.USER,
+        message: 'Hello, world!',
+        timestamp: new Date('2025-01-01T12:00:00.000Z').toISOString(),
+      });
+      expect(logger['logs'].length).toBe(1);
+      expect(logger['logs'][0]).toEqual(logsFromFile[0]);
+      expect(logger['messageId']).toBe(1);
+    });
+
+    it('should correctly increment messageId for subsequent messages in the same session', async () => {
+      await logger.logMessage(MessageSenderType.USER, 'First');
+      vi.advanceTimersByTime(1000);
+      await logger.logMessage(MessageSenderType.USER, 'Second');
+      const logs = await readLogFile();
+      expect(logs.length).toBe(2);
+      expect(logs[0].messageId).toBe(0);
+      expect(logs[1].messageId).toBe(1);
+      expect(logs[1].timestamp).not.toBe(logs[0].timestamp);
+      expect(logger['messageId']).toBe(2);
+    });
+
+    it('should handle logger not initialized', async () => {
+      const uninitializedLogger = new Logger(testSessionId);
+      uninitializedLogger.close(); // Ensure it's treated as uninitialized
+      const consoleDebugSpy = vi
+        .spyOn(console, 'debug')
+        .mockImplementation(() => {});
+      await uninitializedLogger.logMessage(MessageSenderType.USER, 'test');
+      expect(consoleDebugSpy).toHaveBeenCalledWith(
+        'Logger not initialized or session ID missing. Cannot log message.',
+      );
+      expect((await readLogFile()).length).toBe(0);
+      uninitializedLogger.close();
+    });
+
+    it('should simulate concurrent writes from different logger instances to the same file', async () => {
+      const concurrentSessionId = 'concurrent-session';
+      const logger1 = new Logger(concurrentSessionId);
+      await logger1.initialize();
+
+      const logger2 = new Logger(concurrentSessionId);
+      await logger2.initialize();
+      expect(logger2['sessionId']).toEqual(logger1['sessionId']);
+
+      await logger1.logMessage(MessageSenderType.USER, 'L1M1');
+      vi.advanceTimersByTime(10);
+      await logger2.logMessage(MessageSenderType.USER, 'L2M1');
+      vi.advanceTimersByTime(10);
+      await logger1.logMessage(MessageSenderType.USER, 'L1M2');
+      vi.advanceTimersByTime(10);
+      await logger2.logMessage(MessageSenderType.USER, 'L2M2');
+
+      const logsFromFile = await readLogFile();
+      expect(logsFromFile.length).toBe(4);
+      const messageIdsInFile = logsFromFile
+        .map((log) => log.messageId)
+        .sort((a, b) => a - b);
+      expect(messageIdsInFile).toEqual([0, 1, 2, 3]);
+
+      const messagesInFile = logsFromFile
+        .sort((a, b) => a.messageId - b.messageId)
+        .map((l) => l.message);
+      expect(messagesInFile).toEqual(['L1M1', 'L2M1', 'L1M2', 'L2M2']);
+
+      // Check internal state (next messageId each logger would use for that session)
+      expect(logger1['messageId']).toBe(3);
+      expect(logger2['messageId']).toBe(4);
+
+      logger1.close();
+      logger2.close();
+    });
+
+    it('should not throw, not increment messageId, and log error if writing to file fails', async () => {
+      vi.spyOn(fs, 'writeFile').mockRejectedValueOnce(new Error('Disk full'));
+      const consoleDebugSpy = vi
+        .spyOn(console, 'debug')
+        .mockImplementation(() => {});
+      const initialMessageId = logger['messageId'];
+      const initialLogCount = logger['logs'].length;
+
+      await logger.logMessage(MessageSenderType.USER, 'test fail write');
+
+      expect(consoleDebugSpy).toHaveBeenCalledWith(
+        'Error writing to log file:',
+        expect.any(Error),
+      );
+      expect(logger['messageId']).toBe(initialMessageId); // Not incremented
+      expect(logger['logs'].length).toBe(initialLogCount); // Log not added to in-memory cache
+    });
+  });
+
+  describe('getPreviousUserMessages', () => {
+    it('should retrieve all user messages from logs, sorted newest first', async () => {
+      const loggerSort = new Logger('session-1');
+      await loggerSort.initialize();
+      await loggerSort.logMessage(MessageSenderType.USER, 'S1M0_ts100000');
+      vi.advanceTimersByTime(1000);
+      await loggerSort.logMessage(MessageSenderType.USER, 'S1M1_ts101000');
+      vi.advanceTimersByTime(1000);
+      // Switch to a different session to log
+      const loggerSort2 = new Logger('session-2');
+      await loggerSort2.initialize();
+      await loggerSort2.logMessage(MessageSenderType.USER, 'S2M0_ts102000');
+      vi.advanceTimersByTime(1000);
+      await loggerSort2.logMessage(
+        'model' as MessageSenderType,
+        'S2_Model_ts103000',
+      );
+      vi.advanceTimersByTime(1000);
+      await loggerSort2.logMessage(MessageSenderType.USER, 'S2M1_ts104000');
+      loggerSort.close();
+      loggerSort2.close();
+
+      const finalLogger = new Logger('final-session');
+      await finalLogger.initialize();
+
+      const messages = await finalLogger.getPreviousUserMessages();
+      expect(messages).toEqual([
+        'S2M1_ts104000',
+        'S2M0_ts102000',
+        'S1M1_ts101000',
+        'S1M0_ts100000',
+      ]);
+      finalLogger.close();
+    });
+
+    it('should return empty array if no user messages exist', async () => {
+      await logger.logMessage('system' as MessageSenderType, 'System boot');
+      const messages = await logger.getPreviousUserMessages();
+      expect(messages).toEqual([]);
+    });
+
+    it('should return empty array if logger not initialized', async () => {
+      const uninitializedLogger = new Logger(testSessionId);
+      uninitializedLogger.close();
+      const messages = await uninitializedLogger.getPreviousUserMessages();
+      expect(messages).toEqual([]);
+      uninitializedLogger.close();
+    });
+  });
+
+  describe('saveCheckpoint', () => {
+    const conversation: Content[] = [
+      { role: 'user', parts: [{ text: 'Hello' }] },
+      { role: 'model', parts: [{ text: 'Hi there' }] },
+    ];
+
+    it.each([
+      {
+        tag: 'test-tag',
+        encodedTag: 'test-tag',
+      },
+      {
+        tag: '你好世界',
+        encodedTag: '%E4%BD%A0%E5%A5%BD%E4%B8%96%E7%95%8C',
+      },
+      {
+        tag: 'japanese-ひらがなひらがな形声',
+        encodedTag:
+          'japanese-%E3%81%B2%E3%82%89%E3%81%8C%E3%81%AA%E3%81%B2%E3%82%89%E3%81%8C%E3%81%AA%E5%BD%A2%E5%A3%B0',
+      },
+      {
+        tag: '../../secret',
+        encodedTag: '..%2F..%2Fsecret',
+      },
+    ])('should save a checkpoint', async ({ tag, encodedTag }) => {
+      await logger.saveCheckpoint(conversation, tag);
+      const taggedFilePath = path.join(
+        TEST_GEMINI_DIR,
+        `checkpoint-${encodedTag}.json`,
+      );
+      const fileContent = await fs.readFile(taggedFilePath, 'utf-8');
+      expect(JSON.parse(fileContent)).toEqual(conversation);
+    });
+
+    it('should not throw if logger is not initialized', async () => {
+      const uninitializedLogger = new Logger(testSessionId);
+      uninitializedLogger.close();
+      const consoleErrorSpy = vi
+        .spyOn(console, 'error')
+        .mockImplementation(() => {});
+
+      await expect(
+        uninitializedLogger.saveCheckpoint(conversation, 'tag'),
+      ).resolves.not.toThrow();
+      expect(consoleErrorSpy).toHaveBeenCalledWith(
+        'Logger not initialized or checkpoint file path not set. Cannot save a checkpoint.',
+      );
+    });
+  });
+
+  describe('loadCheckpoint', () => {
+    const conversation: Content[] = [
+      { role: 'user', parts: [{ text: 'Hello' }] },
+      { role: 'model', parts: [{ text: 'Hi there' }] },
+    ];
+
+    beforeEach(async () => {
+      await fs.writeFile(
+        TEST_CHECKPOINT_FILE_PATH,
+        JSON.stringify(conversation, null, 2),
+      );
+    });
+
+    it.each([
+      {
+        tag: 'test-tag',
+        encodedTag: 'test-tag',
+      },
+      {
+        tag: '你好世界',
+        encodedTag: '%E4%BD%A0%E5%A5%BD%E4%B8%96%E7%95%8C',
+      },
+      {
+        tag: 'japanese-ひらがなひらがな形声',
+        encodedTag:
+          'japanese-%E3%81%B2%E3%82%89%E3%81%8C%E3%81%AA%E3%81%B2%E3%82%89%E3%81%8C%E3%81%AA%E5%BD%A2%E5%A3%B0',
+      },
+      {
+        tag: '../../secret',
+        encodedTag: '..%2F..%2Fsecret',
+      },
+    ])('should load from a checkpoint', async ({ tag, encodedTag }) => {
+      const taggedConversation = [
+        ...conversation,
+        { role: 'user', parts: [{ text: 'hello' }] },
+      ];
+      const taggedFilePath = path.join(
+        TEST_GEMINI_DIR,
+        `checkpoint-${encodedTag}.json`,
+      );
+      await fs.writeFile(
+        taggedFilePath,
+        JSON.stringify(taggedConversation, null, 2),
+      );
+
+      const loaded = await logger.loadCheckpoint(tag);
+      expect(loaded).toEqual(taggedConversation);
+      expect(encodeTagName(tag)).toBe(encodedTag);
+      expect(decodeTagName(encodedTag)).toBe(tag);
+    });
+
+    it('should return an empty array if a tagged checkpoint file does not exist', async () => {
+      const loaded = await logger.loadCheckpoint('nonexistent-tag');
+      expect(loaded).toEqual([]);
+    });
+
+    it('should return an empty array if the checkpoint file does not exist', async () => {
+      await fs.unlink(TEST_CHECKPOINT_FILE_PATH); // Ensure it's gone
+      const loaded = await logger.loadCheckpoint('missing');
+      expect(loaded).toEqual([]);
+    });
+
+    it('should return an empty array if the file contains invalid JSON', async () => {
+      const tag = 'invalid-json-tag';
+      const encodedTag = 'invalid-json-tag';
+      const taggedFilePath = path.join(
+        TEST_GEMINI_DIR,
+        `checkpoint-${encodedTag}.json`,
+      );
+      await fs.writeFile(taggedFilePath, 'invalid json');
+      const consoleErrorSpy = vi
+        .spyOn(console, 'error')
+        .mockImplementation(() => {});
+      const loadedCheckpoint = await logger.loadCheckpoint(tag);
+      expect(loadedCheckpoint).toEqual([]);
+      expect(consoleErrorSpy).toHaveBeenCalledWith(
+        expect.stringContaining('Failed to read or parse checkpoint file'),
+        expect.any(Error),
+      );
+    });
+
+    it('should return an empty array if logger is not initialized', async () => {
+      const uninitializedLogger = new Logger(testSessionId);
+      uninitializedLogger.close();
+      const consoleErrorSpy = vi
+        .spyOn(console, 'error')
+        .mockImplementation(() => {});
+      const loadedCheckpoint = await uninitializedLogger.loadCheckpoint('tag');
+      expect(loadedCheckpoint).toEqual([]);
+      expect(consoleErrorSpy).toHaveBeenCalledWith(
+        'Logger not initialized or checkpoint file path not set. Cannot load checkpoint.',
+      );
+    });
+  });
+
+  describe('deleteCheckpoint', () => {
+    const conversation: Content[] = [
+      { role: 'user', parts: [{ text: 'Content to be deleted' }] },
+    ];
+    const tag = 'delete-me';
+    const encodedTag = 'delete-me';
+    let taggedFilePath: string;
+
+    beforeEach(async () => {
+      taggedFilePath = path.join(
+        TEST_GEMINI_DIR,
+        `checkpoint-${encodedTag}.json`,
+      );
+      // Create a file to be deleted
+      await fs.writeFile(taggedFilePath, JSON.stringify(conversation));
+    });
+
+    it('should delete the specified checkpoint file and return true', async () => {
+      const result = await logger.deleteCheckpoint(tag);
+      expect(result).toBe(true);
+
+      // Verify the file is actually gone
+      await expect(fs.access(taggedFilePath)).rejects.toThrow(/ENOENT/);
+    });
+
+    it('should delete both new and old checkpoint files if they exist', async () => {
+      const oldTag = 'delete-me(old)';
+      const oldStylePath = path.join(
+        TEST_GEMINI_DIR,
+        `checkpoint-${oldTag}.json`,
+      );
+      const newStylePath = logger['_checkpointPath'](oldTag);
+
+      // Create both files
+      await fs.writeFile(oldStylePath, '{}');
+      await fs.writeFile(newStylePath, '{}');
+
+      // Verify both files exist before deletion
+      expect(existsSync(oldStylePath)).toBe(true);
+      expect(existsSync(newStylePath)).toBe(true);
+
+      const result = await logger.deleteCheckpoint(oldTag);
+      expect(result).toBe(true);
+
+      // Verify both are gone
+      expect(existsSync(oldStylePath)).toBe(false);
+      expect(existsSync(newStylePath)).toBe(false);
+    });
+
+    it('should return false if the checkpoint file does not exist', async () => {
+      const result = await logger.deleteCheckpoint('non-existent-tag');
+      expect(result).toBe(false);
+    });
+
+    it('should re-throw an error if file deletion fails for reasons other than not existing', async () => {
+      // Simulate a different error (e.g., permission denied)
+      vi.spyOn(fs, 'unlink').mockRejectedValueOnce(
+        Object.assign(new Error('EACCES: permission denied'), {
+          code: 'EACCES',
+        }),
+      );
+      const consoleErrorSpy = vi
+        .spyOn(console, 'error')
+        .mockImplementation(() => {});
+
+      await expect(logger.deleteCheckpoint(tag)).rejects.toThrow(
+        'EACCES: permission denied',
+      );
+      expect(consoleErrorSpy).toHaveBeenCalledWith(
+        `Failed to delete checkpoint file ${taggedFilePath}:`,
+        expect.any(Error),
+      );
+    });
+
+    it('should return false if logger is not initialized', async () => {
+      const uninitializedLogger = new Logger(testSessionId);
+      uninitializedLogger.close();
+      const consoleErrorSpy = vi
+        .spyOn(console, 'error')
+        .mockImplementation(() => {});
+
+      const result = await uninitializedLogger.deleteCheckpoint(tag);
+      expect(result).toBe(false);
+      expect(consoleErrorSpy).toHaveBeenCalledWith(
+        'Logger not initialized or checkpoint file path not set. Cannot delete checkpoint.',
+      );
+    });
+  });
+
+  describe('checkpointExists', () => {
+    const tag = 'exists-test';
+    const encodedTag = 'exists-test';
+    let taggedFilePath: string;
+
+    beforeEach(() => {
+      taggedFilePath = path.join(
+        TEST_GEMINI_DIR,
+        `checkpoint-${encodedTag}.json`,
+      );
+    });
+
+    it('should return true if the checkpoint file exists', async () => {
+      await fs.writeFile(taggedFilePath, '{}');
+      const exists = await logger.checkpointExists(tag);
+      expect(exists).toBe(true);
+    });
+
+    it('should return false if the checkpoint file does not exist', async () => {
+      const exists = await logger.checkpointExists('non-existent-tag');
+      expect(exists).toBe(false);
+    });
+
+    it('should throw an error if logger is not initialized', async () => {
+      const uninitializedLogger = new Logger(testSessionId);
+      uninitializedLogger.close();
+
+      await expect(uninitializedLogger.checkpointExists(tag)).rejects.toThrow(
+        'Logger not initialized. Cannot check for checkpoint existence.',
+      );
+    });
+
+    it('should re-throw an error if fs.access fails for reasons other than not existing', async () => {
+      vi.spyOn(fs, 'access').mockRejectedValueOnce(
+        Object.assign(new Error('EACCES: permission denied'), {
+          code: 'EACCES',
+        }),
+      );
+      const consoleErrorSpy = vi
+        .spyOn(console, 'error')
+        .mockImplementation(() => {});
+
+      await expect(logger.checkpointExists(tag)).rejects.toThrow(
+        'EACCES: permission denied',
+      );
+      expect(consoleErrorSpy).toHaveBeenCalledWith(
+        `Failed to check checkpoint existence for path for tag "${tag}":`,
+        expect.any(Error),
+      );
+    });
+  });
+
+  describe('Backward compatibility', () => {
+    const conversation: Content[] = [
+      { role: 'user', parts: [{ text: 'Hello' }] },
+      { role: 'model', parts: [{ text: 'Hi there' }] },
+    ];
+    it('should load from a checkpoint with a raw special character tag', async () => {
+      const taggedConversation = [
+        ...conversation,
+        { role: 'user', parts: [{ text: 'hello' }] },
+      ];
+      const tag = 'special(char)';
+      const taggedFilePath = path.join(
+        TEST_GEMINI_DIR,
+        `checkpoint-${tag}.json`,
+      );
+      await fs.writeFile(
+        taggedFilePath,
+        JSON.stringify(taggedConversation, null, 2),
+      );
+
+      const loaded = await logger.loadCheckpoint(tag);
+      expect(loaded).toEqual(taggedConversation);
+    });
+  });
+
+  describe('close', () => {
+    it('should reset logger state', async () => {
+      await logger.logMessage(MessageSenderType.USER, 'A message');
+      logger.close();
+      const consoleDebugSpy = vi
+        .spyOn(console, 'debug')
+        .mockImplementation(() => {});
+      await logger.logMessage(MessageSenderType.USER, 'Another message');
+      expect(consoleDebugSpy).toHaveBeenCalledWith(
+        'Logger not initialized or session ID missing. Cannot log message.',
+      );
+      const messages = await logger.getPreviousUserMessages();
+      expect(messages).toEqual([]);
+      expect(logger['initialized']).toBe(false);
+      expect(logger['logFilePath']).toBeUndefined();
+      expect(logger['logs']).toEqual([]);
+      expect(logger['sessionId']).toBeUndefined();
+      expect(logger['messageId']).toBe(0);
+    });
+  });
+});

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

@@ -0,0 +1,437 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import path from 'node:path';
+import { promises as fs } from 'node:fs';
+import { Content } from '@google/genai';
+import { getProjectTempDir } from '../utils/paths.js';
+
+const LOG_FILE_NAME = 'logs.json';
+
+export enum MessageSenderType {
+  USER = 'user',
+}
+
+export interface LogEntry {
+  sessionId: string;
+  messageId: number;
+  timestamp: string;
+  type: MessageSenderType;
+  message: string;
+}
+
+// This regex matches any character that is NOT a letter (a-z, A-Z),
+// a number (0-9), a hyphen (-), an underscore (_), or a dot (.).
+
+/**
+ * Encodes a string to be safe for use as a filename.
+ *
+ * It replaces any characters that are not alphanumeric or one of `_`, `-`, `.`
+ * with a URL-like percent-encoding (`%` followed by the 2-digit hex code).
+ *
+ * @param str The input string to encode.
+ * @returns The encoded, filename-safe string.
+ */
+export function encodeTagName(str: string): string {
+  return encodeURIComponent(str);
+}
+
+/**
+ * Decodes a string that was encoded with the `encode` function.
+ *
+ * It finds any percent-encoded characters and converts them back to their
+ * original representation.
+ *
+ * @param str The encoded string to decode.
+ * @returns The decoded, original string.
+ */
+export function decodeTagName(str: string): string {
+  try {
+    return decodeURIComponent(str);
+  } catch (_e) {
+    // Fallback for old, potentially malformed encoding
+    return str.replace(/%([0-9A-F]{2})/g, (_, hex) =>
+      String.fromCharCode(parseInt(hex, 16)),
+    );
+  }
+}
+
+export class Logger {
+  private qwenDir: string | undefined;
+  private logFilePath: string | undefined;
+  private sessionId: string | undefined;
+  private messageId = 0; // Instance-specific counter for the next messageId
+  private initialized = false;
+  private logs: LogEntry[] = []; // In-memory cache, ideally reflects the last known state of the file
+
+  constructor(sessionId: string) {
+    this.sessionId = sessionId;
+  }
+
+  private async _readLogFile(): Promise<LogEntry[]> {
+    if (!this.logFilePath) {
+      throw new Error('Log file path not set during read attempt.');
+    }
+    try {
+      const fileContent = await fs.readFile(this.logFilePath, 'utf-8');
+      const parsedLogs = JSON.parse(fileContent);
+      if (!Array.isArray(parsedLogs)) {
+        console.debug(
+          `Log file at ${this.logFilePath} is not a valid JSON array. Starting with empty logs.`,
+        );
+        await this._backupCorruptedLogFile('malformed_array');
+        return [];
+      }
+      return parsedLogs.filter(
+        (entry) =>
+          typeof entry.sessionId === 'string' &&
+          typeof entry.messageId === 'number' &&
+          typeof entry.timestamp === 'string' &&
+          typeof entry.type === 'string' &&
+          typeof entry.message === 'string',
+      ) as LogEntry[];
+    } catch (error) {
+      const nodeError = error as NodeJS.ErrnoException;
+      if (nodeError.code === 'ENOENT') {
+        return [];
+      }
+      if (error instanceof SyntaxError) {
+        console.debug(
+          `Invalid JSON in log file ${this.logFilePath}. Backing up and starting fresh.`,
+          error,
+        );
+        await this._backupCorruptedLogFile('invalid_json');
+        return [];
+      }
+      console.debug(
+        `Failed to read or parse log file ${this.logFilePath}:`,
+        error,
+      );
+      throw error;
+    }
+  }
+
+  private async _backupCorruptedLogFile(reason: string): Promise<void> {
+    if (!this.logFilePath) return;
+    const backupPath = `${this.logFilePath}.${reason}.${Date.now()}.bak`;
+    try {
+      await fs.rename(this.logFilePath, backupPath);
+      console.debug(`Backed up corrupted log file to ${backupPath}`);
+    } catch (_backupError) {
+      // If rename fails (e.g. file doesn't exist), no need to log an error here as the primary error (e.g. invalid JSON) is already handled.
+    }
+  }
+
+  async initialize(): Promise<void> {
+    if (this.initialized) {
+      return;
+    }
+
+    this.qwenDir = getProjectTempDir(process.cwd());
+    this.logFilePath = path.join(this.qwenDir, LOG_FILE_NAME);
+
+    try {
+      await fs.mkdir(this.qwenDir, { recursive: true });
+      let fileExisted = true;
+      try {
+        await fs.access(this.logFilePath);
+      } catch (_e) {
+        fileExisted = false;
+      }
+      this.logs = await this._readLogFile();
+      if (!fileExisted && this.logs.length === 0) {
+        await fs.writeFile(this.logFilePath, '[]', 'utf-8');
+      }
+      const sessionLogs = this.logs.filter(
+        (entry) => entry.sessionId === this.sessionId,
+      );
+      this.messageId =
+        sessionLogs.length > 0
+          ? Math.max(...sessionLogs.map((entry) => entry.messageId)) + 1
+          : 0;
+      this.initialized = true;
+    } catch (err) {
+      console.error('Failed to initialize logger:', err);
+      this.initialized = false;
+    }
+  }
+
+  private async _updateLogFile(
+    entryToAppend: LogEntry,
+  ): Promise<LogEntry | null> {
+    if (!this.logFilePath) {
+      console.debug('Log file path not set. Cannot persist log entry.');
+      throw new Error('Log file path not set during update attempt.');
+    }
+
+    let currentLogsOnDisk: LogEntry[];
+    try {
+      currentLogsOnDisk = await this._readLogFile();
+    } catch (readError) {
+      console.debug(
+        'Critical error reading log file before append:',
+        readError,
+      );
+      throw readError;
+    }
+
+    // Determine the correct messageId for the new entry based on current disk state for its session
+    const sessionLogsOnDisk = currentLogsOnDisk.filter(
+      (e) => e.sessionId === entryToAppend.sessionId,
+    );
+    const nextMessageIdForSession =
+      sessionLogsOnDisk.length > 0
+        ? Math.max(...sessionLogsOnDisk.map((e) => e.messageId)) + 1
+        : 0;
+
+    // Update the messageId of the entry we are about to append
+    entryToAppend.messageId = nextMessageIdForSession;
+
+    // Check if this entry (same session, same *recalculated* messageId, same content) might already exist
+    // This is a stricter check for true duplicates if multiple instances try to log the exact same thing
+    // at the exact same calculated messageId slot.
+    const entryExists = currentLogsOnDisk.some(
+      (e) =>
+        e.sessionId === entryToAppend.sessionId &&
+        e.messageId === entryToAppend.messageId &&
+        e.timestamp === entryToAppend.timestamp && // Timestamps are good for distinguishing
+        e.message === entryToAppend.message,
+    );
+
+    if (entryExists) {
+      console.debug(
+        `Duplicate log entry detected and skipped: session ${entryToAppend.sessionId}, messageId ${entryToAppend.messageId}`,
+      );
+      this.logs = currentLogsOnDisk; // Ensure in-memory is synced with disk
+      return null; // Indicate that no new entry was actually added
+    }
+
+    currentLogsOnDisk.push(entryToAppend);
+
+    try {
+      await fs.writeFile(
+        this.logFilePath,
+        JSON.stringify(currentLogsOnDisk, null, 2),
+        'utf-8',
+      );
+      this.logs = currentLogsOnDisk;
+      return entryToAppend; // Return the successfully appended entry
+    } catch (error) {
+      console.debug('Error writing to log file:', error);
+      throw error;
+    }
+  }
+
+  async getPreviousUserMessages(): Promise<string[]> {
+    if (!this.initialized) return [];
+    return this.logs
+      .filter((entry) => entry.type === MessageSenderType.USER)
+      .sort((a, b) => {
+        const dateA = new Date(a.timestamp).getTime();
+        const dateB = new Date(b.timestamp).getTime();
+        return dateB - dateA;
+      })
+      .map((entry) => entry.message);
+  }
+
+  async logMessage(type: MessageSenderType, message: string): Promise<void> {
+    if (!this.initialized || this.sessionId === undefined) {
+      console.debug(
+        'Logger not initialized or session ID missing. Cannot log message.',
+      );
+      return;
+    }
+
+    // The messageId used here is the instance's idea of the next ID.
+    // _updateLogFile will verify and potentially recalculate based on the file's actual state.
+    const newEntryObject: LogEntry = {
+      sessionId: this.sessionId,
+      messageId: this.messageId, // This will be recalculated in _updateLogFile
+      type,
+      message,
+      timestamp: new Date().toISOString(),
+    };
+
+    try {
+      const writtenEntry = await this._updateLogFile(newEntryObject);
+      if (writtenEntry) {
+        // If an entry was actually written (not a duplicate skip),
+        // then this instance can increment its idea of the next messageId for this session.
+        this.messageId = writtenEntry.messageId + 1;
+      }
+    } catch (_error) {
+      // Error already logged by _updateLogFile or _readLogFile
+    }
+  }
+
+  private _checkpointPath(tag: string): string {
+    if (!tag.length) {
+      throw new Error('No checkpoint tag specified.');
+    }
+    if (!this.qwenDir) {
+      throw new Error('Checkpoint file path not set.');
+    }
+    // Encode the tag to handle all special characters safely.
+    const encodedTag = encodeTagName(tag);
+    return path.join(this.qwenDir, `checkpoint-${encodedTag}.json`);
+  }
+
+  private async _getCheckpointPath(tag: string): Promise<string> {
+    // 1. Check for the new encoded path first.
+    const newPath = this._checkpointPath(tag);
+    try {
+      await fs.access(newPath);
+      return newPath; // Found it, use the new path.
+    } catch (error) {
+      const nodeError = error as NodeJS.ErrnoException;
+      if (nodeError.code !== 'ENOENT') {
+        throw error; // A real error occurred, rethrow it.
+      }
+      // It was not found, so we'll check the old path next.
+    }
+
+    // 2. Fallback for backward compatibility: check for the old raw path.
+    const oldPath = path.join(this.qwenDir!, `checkpoint-${tag}.json`);
+    try {
+      await fs.access(oldPath);
+      return oldPath; // Found it, use the old path.
+    } catch (error) {
+      const nodeError = error as NodeJS.ErrnoException;
+      if (nodeError.code !== 'ENOENT') {
+        throw error; // A real error occurred, rethrow it.
+      }
+    }
+
+    // 3. If neither path exists, return the new encoded path as the canonical one.
+    return newPath;
+  }
+
+  async saveCheckpoint(conversation: Content[], tag: string): Promise<void> {
+    if (!this.initialized) {
+      console.error(
+        'Logger not initialized or checkpoint file path not set. Cannot save a checkpoint.',
+      );
+      return;
+    }
+    // Always save with the new encoded path.
+    const path = this._checkpointPath(tag);
+    try {
+      await fs.writeFile(path, JSON.stringify(conversation, null, 2), 'utf-8');
+    } catch (error) {
+      console.error('Error writing to checkpoint file:', error);
+    }
+  }
+
+  async loadCheckpoint(tag: string): Promise<Content[]> {
+    if (!this.initialized) {
+      console.error(
+        'Logger not initialized or checkpoint file path not set. Cannot load checkpoint.',
+      );
+      return [];
+    }
+
+    const path = await this._getCheckpointPath(tag);
+    try {
+      const fileContent = await fs.readFile(path, 'utf-8');
+      const parsedContent = JSON.parse(fileContent);
+      if (!Array.isArray(parsedContent)) {
+        console.warn(
+          `Checkpoint file at ${path} is not a valid JSON array. Returning empty checkpoint.`,
+        );
+        return [];
+      }
+      return parsedContent as Content[];
+    } catch (error) {
+      const nodeError = error as NodeJS.ErrnoException;
+      if (nodeError.code === 'ENOENT') {
+        // This is okay, it just means the checkpoint doesn't exist in either format.
+        return [];
+      }
+      console.error(`Failed to read or parse checkpoint file ${path}:`, error);
+      return [];
+    }
+  }
+
+  async deleteCheckpoint(tag: string): Promise<boolean> {
+    if (!this.initialized || !this.qwenDir) {
+      console.error(
+        'Logger not initialized or checkpoint file path not set. Cannot delete checkpoint.',
+      );
+      return false;
+    }
+
+    let deletedSomething = false;
+
+    // 1. Attempt to delete the new encoded path.
+    const newPath = this._checkpointPath(tag);
+    try {
+      await fs.unlink(newPath);
+      deletedSomething = true;
+    } catch (error) {
+      const nodeError = error as NodeJS.ErrnoException;
+      if (nodeError.code !== 'ENOENT') {
+        console.error(`Failed to delete checkpoint file ${newPath}:`, error);
+        throw error; // Rethrow unexpected errors
+      }
+      // It's okay if it doesn't exist.
+    }
+
+    // 2. Attempt to delete the old raw path for backward compatibility.
+    const oldPath = path.join(this.qwenDir!, `checkpoint-${tag}.json`);
+    if (newPath !== oldPath) {
+      try {
+        await fs.unlink(oldPath);
+        deletedSomething = true;
+      } catch (error) {
+        const nodeError = error as NodeJS.ErrnoException;
+        if (nodeError.code !== 'ENOENT') {
+          console.error(`Failed to delete checkpoint file ${oldPath}:`, error);
+          throw error; // Rethrow unexpected errors
+        }
+        // It's okay if it doesn't exist.
+      }
+    }
+
+    return deletedSomething;
+  }
+
+  async checkpointExists(tag: string): Promise<boolean> {
+    if (!this.initialized) {
+      throw new Error(
+        'Logger not initialized. Cannot check for checkpoint existence.',
+      );
+    }
+    let filePath: string | undefined;
+    try {
+      filePath = await this._getCheckpointPath(tag);
+      // We need to check for existence again, because _getCheckpointPath
+      // returns a canonical path even if it doesn't exist yet.
+      await fs.access(filePath);
+      return true;
+    } catch (error) {
+      const nodeError = error as NodeJS.ErrnoException;
+      if (nodeError.code === 'ENOENT') {
+        return false; // It truly doesn't exist in either format.
+      }
+      // A different error occurred.
+      console.error(
+        `Failed to check checkpoint existence for ${
+          filePath ?? `path for tag "${tag}"`
+        }:`,
+        error,
+      );
+      throw error;
+    }
+  }
+
+  close(): void {
+    this.initialized = false;
+    this.logFilePath = undefined;
+    this.logs = [];
+    this.sessionId = undefined;
+    this.messageId = 0;
+  }
+}

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

@@ -0,0 +1,192 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import {
+  Content,
+  CountTokensParameters,
+  CountTokensResponse,
+  EmbedContentParameters,
+  EmbedContentResponse,
+  GenerateContentParameters,
+  GenerateContentResponseUsageMetadata,
+  GenerateContentResponse,
+} from '@google/genai';
+import {
+  ApiRequestEvent,
+  ApiResponseEvent,
+  ApiErrorEvent,
+} from '../telemetry/types.js';
+import { Config } from '../config/config.js';
+import {
+  logApiError,
+  logApiRequest,
+  logApiResponse,
+} from '../telemetry/loggers.js';
+import { ContentGenerator } from './contentGenerator.js';
+import { toContents } from '../code_assist/converter.js';
+import { isStructuredError } from '../utils/quotaErrorDetection.js';
+
+interface StructuredError {
+  status: number;
+}
+
+/**
+ * A decorator that wraps a ContentGenerator to add logging to API calls.
+ */
+export class LoggingContentGenerator implements ContentGenerator {
+  constructor(
+    private readonly wrapped: ContentGenerator,
+    private readonly config: Config,
+  ) {}
+
+  getWrapped(): ContentGenerator {
+    return this.wrapped;
+  }
+
+  private logApiRequest(
+    contents: Content[],
+    model: string,
+    promptId: string,
+  ): void {
+    const requestText = JSON.stringify(contents);
+    logApiRequest(
+      this.config,
+      new ApiRequestEvent(model, promptId, requestText),
+    );
+  }
+
+  private _logApiResponse(
+    responseId: string,
+    durationMs: number,
+    prompt_id: string,
+    usageMetadata?: GenerateContentResponseUsageMetadata,
+    responseText?: string,
+  ): void {
+    logApiResponse(
+      this.config,
+      new ApiResponseEvent(
+        responseId,
+        this.config.getModel(),
+        durationMs,
+        prompt_id,
+        this.config.getContentGeneratorConfig()?.authType,
+        usageMetadata,
+        responseText,
+      ),
+    );
+  }
+
+  private _logApiError(
+    responseId: string | undefined,
+    durationMs: number,
+    error: unknown,
+    prompt_id: string,
+  ): void {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    const errorType = error instanceof Error ? error.name : 'unknown';
+
+    logApiError(
+      this.config,
+      new ApiErrorEvent(
+        responseId,
+        this.config.getModel(),
+        errorMessage,
+        durationMs,
+        prompt_id,
+        this.config.getContentGeneratorConfig()?.authType,
+        errorType,
+        isStructuredError(error)
+          ? (error as StructuredError).status
+          : undefined,
+      ),
+    );
+  }
+
+  async generateContent(
+    req: GenerateContentParameters,
+    userPromptId: string,
+  ): Promise<GenerateContentResponse> {
+    const startTime = Date.now();
+    this.logApiRequest(toContents(req.contents), req.model, userPromptId);
+    try {
+      const response = await this.wrapped.generateContent(req, userPromptId);
+      const durationMs = Date.now() - startTime;
+      this._logApiResponse(
+        response.responseId ?? '',
+        durationMs,
+        userPromptId,
+        response.usageMetadata,
+        JSON.stringify(response),
+      );
+      return response;
+    } catch (error) {
+      const durationMs = Date.now() - startTime;
+      this._logApiError(undefined, durationMs, error, userPromptId);
+      throw error;
+    }
+  }
+
+  async generateContentStream(
+    req: GenerateContentParameters,
+    userPromptId: string,
+  ): Promise<AsyncGenerator<GenerateContentResponse>> {
+    const startTime = Date.now();
+    this.logApiRequest(toContents(req.contents), req.model, userPromptId);
+
+    let stream: AsyncGenerator<GenerateContentResponse>;
+    try {
+      stream = await this.wrapped.generateContentStream(req, userPromptId);
+    } catch (error) {
+      const durationMs = Date.now() - startTime;
+      this._logApiError(undefined, durationMs, error, userPromptId);
+      throw error;
+    }
+
+    return this.loggingStreamWrapper(stream, startTime, userPromptId);
+  }
+
+  private async *loggingStreamWrapper(
+    stream: AsyncGenerator<GenerateContentResponse>,
+    startTime: number,
+    userPromptId: string,
+  ): AsyncGenerator<GenerateContentResponse> {
+    let lastResponse: GenerateContentResponse | undefined;
+    let lastUsageMetadata: GenerateContentResponseUsageMetadata | undefined;
+    try {
+      for await (const response of stream) {
+        lastResponse = response;
+        if (response.usageMetadata) {
+          lastUsageMetadata = response.usageMetadata;
+        }
+        yield response;
+      }
+    } catch (error) {
+      const durationMs = Date.now() - startTime;
+      this._logApiError(undefined, durationMs, error, userPromptId);
+      throw error;
+    }
+    const durationMs = Date.now() - startTime;
+    if (lastResponse) {
+      this._logApiResponse(
+        lastResponse.responseId ?? '',
+        durationMs,
+        userPromptId,
+        lastUsageMetadata,
+        JSON.stringify(lastResponse),
+      );
+    }
+  }
+
+  async countTokens(req: CountTokensParameters): Promise<CountTokensResponse> {
+    return this.wrapped.countTokens(req);
+  }
+
+  async embedContent(
+    req: EmbedContentParameters,
+  ): Promise<EmbedContentResponse> {
+    return this.wrapped.embedContent(req);
+  }
+}

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

@@ -0,0 +1,279 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { executeToolCall } from './nonInteractiveToolExecutor.js';
+import {
+  ToolRegistry,
+  ToolCallRequestInfo,
+  ToolResult,
+  Config,
+  ToolErrorType,
+} from '../index.js';
+import { Part } from '@google/genai';
+import { MockTool } from '../test-utils/tools.js';
+
+describe('executeToolCall', () => {
+  let mockToolRegistry: ToolRegistry;
+  let mockTool: MockTool;
+  let abortController: AbortController;
+  let mockConfig: Config;
+
+  beforeEach(() => {
+    mockTool = new MockTool();
+
+    mockToolRegistry = {
+      getTool: vi.fn(),
+      // Add other ToolRegistry methods if needed, or use a more complete mock
+    } as unknown as ToolRegistry;
+
+    mockConfig = {
+      getSessionId: () => 'test-session-id',
+      getUsageStatisticsEnabled: () => true,
+      getDebugMode: () => false,
+      getContentGeneratorConfig: () => ({
+        model: 'test-model',
+        authType: 'oauth-personal',
+      }),
+      getToolRegistry: () => mockToolRegistry,
+    } as unknown as Config;
+
+    abortController = new AbortController();
+  });
+
+  it('should execute a tool successfully', async () => {
+    const request: ToolCallRequestInfo = {
+      callId: 'call1',
+      name: 'testTool',
+      args: { param1: 'value1' },
+      isClientInitiated: false,
+      prompt_id: 'prompt-id-1',
+    };
+    const toolResult: ToolResult = {
+      llmContent: 'Tool executed successfully',
+      returnDisplay: 'Success!',
+    };
+    vi.mocked(mockToolRegistry.getTool).mockReturnValue(mockTool);
+    vi.spyOn(mockTool, 'validateBuildAndExecute').mockResolvedValue(toolResult);
+
+    const response = await executeToolCall(
+      mockConfig,
+      request,
+      abortController.signal,
+    );
+
+    expect(mockToolRegistry.getTool).toHaveBeenCalledWith('testTool');
+    expect(mockTool.validateBuildAndExecute).toHaveBeenCalledWith(
+      request.args,
+      abortController.signal,
+    );
+    expect(response.callId).toBe('call1');
+    expect(response.error).toBeUndefined();
+    expect(response.resultDisplay).toBe('Success!');
+    expect(response.responseParts).toEqual({
+      functionResponse: {
+        name: 'testTool',
+        id: 'call1',
+        response: { output: 'Tool executed successfully' },
+      },
+    });
+  });
+
+  it('should return an error if tool is not found', async () => {
+    const request: ToolCallRequestInfo = {
+      callId: 'call2',
+      name: 'nonexistentTool',
+      args: {},
+      isClientInitiated: false,
+      prompt_id: 'prompt-id-2',
+    };
+    vi.mocked(mockToolRegistry.getTool).mockReturnValue(undefined);
+
+    const response = await executeToolCall(
+      mockConfig,
+      request,
+      abortController.signal,
+    );
+
+    expect(response.callId).toBe('call2');
+    expect(response.error).toBeInstanceOf(Error);
+    expect(response.error?.message).toBe(
+      'Tool "nonexistentTool" not found in registry.',
+    );
+    expect(response.resultDisplay).toBe(
+      'Tool "nonexistentTool" not found in registry.',
+    );
+    expect(response.responseParts).toEqual([
+      {
+        functionResponse: {
+          name: 'nonexistentTool',
+          id: 'call2',
+          response: { error: 'Tool "nonexistentTool" not found in registry.' },
+        },
+      },
+    ]);
+  });
+
+  it('should return an error if tool validation fails', async () => {
+    const request: ToolCallRequestInfo = {
+      callId: 'call3',
+      name: 'testTool',
+      args: { param1: 'invalid' },
+      isClientInitiated: false,
+      prompt_id: 'prompt-id-3',
+    };
+    const validationErrorResult: ToolResult = {
+      llmContent: 'Error: Invalid parameters',
+      returnDisplay: 'Invalid parameters',
+      error: {
+        message: 'Invalid parameters',
+        type: ToolErrorType.INVALID_TOOL_PARAMS,
+      },
+    };
+    vi.mocked(mockToolRegistry.getTool).mockReturnValue(mockTool);
+    vi.spyOn(mockTool, 'validateBuildAndExecute').mockResolvedValue(
+      validationErrorResult,
+    );
+
+    const response = await executeToolCall(
+      mockConfig,
+      request,
+      abortController.signal,
+    );
+    expect(response).toStrictEqual({
+      callId: 'call3',
+      error: new Error('Invalid parameters'),
+      errorType: ToolErrorType.INVALID_TOOL_PARAMS,
+      responseParts: {
+        functionResponse: {
+          id: 'call3',
+          name: 'testTool',
+          response: {
+            output: 'Error: Invalid parameters',
+          },
+        },
+      },
+      resultDisplay: 'Invalid parameters',
+    });
+  });
+
+  it('should return an error if tool execution fails', async () => {
+    const request: ToolCallRequestInfo = {
+      callId: 'call4',
+      name: 'testTool',
+      args: { param1: 'value1' },
+      isClientInitiated: false,
+      prompt_id: 'prompt-id-4',
+    };
+    const executionErrorResult: ToolResult = {
+      llmContent: 'Error: Execution failed',
+      returnDisplay: 'Execution failed',
+      error: {
+        message: 'Execution failed',
+        type: ToolErrorType.EXECUTION_FAILED,
+      },
+    };
+    vi.mocked(mockToolRegistry.getTool).mockReturnValue(mockTool);
+    vi.spyOn(mockTool, 'validateBuildAndExecute').mockResolvedValue(
+      executionErrorResult,
+    );
+
+    const response = await executeToolCall(
+      mockConfig,
+      request,
+      abortController.signal,
+    );
+    expect(response).toStrictEqual({
+      callId: 'call4',
+      error: new Error('Execution failed'),
+      errorType: ToolErrorType.EXECUTION_FAILED,
+      responseParts: {
+        functionResponse: {
+          id: 'call4',
+          name: 'testTool',
+          response: {
+            output: 'Error: Execution failed',
+          },
+        },
+      },
+      resultDisplay: 'Execution failed',
+    });
+  });
+
+  it('should return an unhandled exception error if execution throws', async () => {
+    const request: ToolCallRequestInfo = {
+      callId: 'call5',
+      name: 'testTool',
+      args: { param1: 'value1' },
+      isClientInitiated: false,
+      prompt_id: 'prompt-id-5',
+    };
+    const executionError = new Error('Something went very wrong');
+    vi.mocked(mockToolRegistry.getTool).mockReturnValue(mockTool);
+    vi.spyOn(mockTool, 'validateBuildAndExecute').mockRejectedValue(
+      executionError,
+    );
+
+    const response = await executeToolCall(
+      mockConfig,
+      request,
+      abortController.signal,
+    );
+
+    expect(response.callId).toBe('call5');
+    expect(response.error).toBe(executionError);
+    expect(response.errorType).toBe(ToolErrorType.UNHANDLED_EXCEPTION);
+    expect(response.resultDisplay).toBe('Something went very wrong');
+    expect(response.responseParts).toEqual([
+      {
+        functionResponse: {
+          name: 'testTool',
+          id: 'call5',
+          response: { error: 'Something went very wrong' },
+        },
+      },
+    ]);
+  });
+
+  it('should correctly format llmContent with inlineData', async () => {
+    const request: ToolCallRequestInfo = {
+      callId: 'call6',
+      name: 'testTool',
+      args: {},
+      isClientInitiated: false,
+      prompt_id: 'prompt-id-6',
+    };
+    const imageDataPart: Part = {
+      inlineData: { mimeType: 'image/png', data: 'base64data' },
+    };
+    const toolResult: ToolResult = {
+      llmContent: [imageDataPart],
+      returnDisplay: 'Image processed',
+    };
+    vi.mocked(mockToolRegistry.getTool).mockReturnValue(mockTool);
+    vi.spyOn(mockTool, 'validateBuildAndExecute').mockResolvedValue(toolResult);
+
+    const response = await executeToolCall(
+      mockConfig,
+      request,
+      abortController.signal,
+    );
+
+    expect(response.resultDisplay).toBe('Image processed');
+    expect(response.responseParts).toEqual([
+      {
+        functionResponse: {
+          name: 'testTool',
+          id: 'call6',
+          response: {
+            output: 'Binary content of type image/png was processed.',
+          },
+        },
+      },
+      imageDataPart,
+    ]);
+  });
+});

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

@@ -0,0 +1,169 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import {
+  FileDiff,
+  logToolCall,
+  ToolCallRequestInfo,
+  ToolCallResponseInfo,
+  ToolErrorType,
+  ToolResult,
+} from '../index.js';
+import { DiscoveredMCPTool } from '../tools/mcp-tool.js';
+import { Config } from '../config/config.js';
+import { convertToFunctionResponse } from './coreToolScheduler.js';
+import { ToolCallDecision } from '../telemetry/tool-call-decision.js';
+
+/**
+ * Executes a single tool call non-interactively.
+ * It does not handle confirmations, multiple calls, or live updates.
+ */
+export async function executeToolCall(
+  config: Config,
+  toolCallRequest: ToolCallRequestInfo,
+  abortSignal?: AbortSignal,
+): Promise<ToolCallResponseInfo> {
+  const tool = config.getToolRegistry().getTool(toolCallRequest.name);
+
+  const startTime = Date.now();
+  if (!tool) {
+    const error = new Error(
+      `Tool "${toolCallRequest.name}" not found in registry.`,
+    );
+    const durationMs = Date.now() - startTime;
+    logToolCall(config, {
+      'event.name': 'tool_call',
+      'event.timestamp': new Date().toISOString(),
+      function_name: toolCallRequest.name,
+      function_args: toolCallRequest.args,
+      duration_ms: durationMs,
+      success: false,
+      error: error.message,
+      prompt_id: toolCallRequest.prompt_id,
+      tool_type: 'native',
+    });
+    // Ensure the response structure matches what the API expects for an error
+    return {
+      callId: toolCallRequest.callId,
+      responseParts: [
+        {
+          functionResponse: {
+            id: toolCallRequest.callId,
+            name: toolCallRequest.name,
+            response: { error: error.message },
+          },
+        },
+      ],
+      resultDisplay: error.message,
+      error,
+      errorType: ToolErrorType.TOOL_NOT_REGISTERED,
+    };
+  }
+
+  try {
+    // Directly execute without confirmation or live output handling
+    const effectiveAbortSignal = abortSignal ?? new AbortController().signal;
+    const toolResult: ToolResult = await tool.validateBuildAndExecute(
+      toolCallRequest.args,
+      effectiveAbortSignal,
+      // No live output callback for non-interactive mode
+    );
+
+    const tool_output = toolResult.llmContent;
+
+    const tool_display = toolResult.returnDisplay;
+
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    let metadata: { [key: string]: any } = {};
+    if (
+      toolResult.error === undefined &&
+      typeof tool_display === 'object' &&
+      tool_display !== null &&
+      'diffStat' in tool_display
+    ) {
+      const diffStat = (tool_display as FileDiff).diffStat;
+      if (diffStat) {
+        metadata = {
+          ai_added_lines: diffStat.ai_added_lines,
+          ai_removed_lines: diffStat.ai_removed_lines,
+          user_added_lines: diffStat.user_added_lines,
+          user_removed_lines: diffStat.user_removed_lines,
+        };
+      }
+    }
+    const durationMs = Date.now() - startTime;
+    logToolCall(config, {
+      'event.name': 'tool_call',
+      'event.timestamp': new Date().toISOString(),
+      function_name: toolCallRequest.name,
+      function_args: toolCallRequest.args,
+      duration_ms: durationMs,
+      success: toolResult.error === undefined,
+      error:
+        toolResult.error === undefined ? undefined : toolResult.error.message,
+      error_type:
+        toolResult.error === undefined ? undefined : toolResult.error.type,
+      prompt_id: toolCallRequest.prompt_id,
+      metadata,
+      decision: ToolCallDecision.AUTO_ACCEPT,
+      tool_type:
+        typeof tool !== 'undefined' && tool instanceof DiscoveredMCPTool
+          ? 'mcp'
+          : 'native',
+    });
+
+    const response = convertToFunctionResponse(
+      toolCallRequest.name,
+      toolCallRequest.callId,
+      tool_output,
+    );
+
+    return {
+      callId: toolCallRequest.callId,
+      responseParts: response,
+      resultDisplay: tool_display,
+      error:
+        toolResult.error === undefined
+          ? undefined
+          : new Error(toolResult.error.message),
+      errorType:
+        toolResult.error === undefined ? undefined : toolResult.error.type,
+    };
+  } catch (e) {
+    const error = e instanceof Error ? e : new Error(String(e));
+    const durationMs = Date.now() - startTime;
+    logToolCall(config, {
+      'event.name': 'tool_call',
+      'event.timestamp': new Date().toISOString(),
+      function_name: toolCallRequest.name,
+      function_args: toolCallRequest.args,
+      duration_ms: durationMs,
+      success: false,
+      error: error.message,
+      error_type: ToolErrorType.UNHANDLED_EXCEPTION,
+      prompt_id: toolCallRequest.prompt_id,
+      tool_type:
+        typeof tool !== 'undefined' && tool instanceof DiscoveredMCPTool
+          ? 'mcp'
+          : 'native',
+    });
+    return {
+      callId: toolCallRequest.callId,
+      responseParts: [
+        {
+          functionResponse: {
+            id: toolCallRequest.callId,
+            name: toolCallRequest.name,
+            response: { error: error.message },
+          },
+        },
+      ],
+      resultDisplay: error.message,
+      error,
+      errorType: ToolErrorType.UNHANDLED_EXCEPTION,
+    };
+  }
+}

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

@@ -0,0 +1,1696 @@
+/**
+ * @license
+ * Copyright 2025 Qwen
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import {
+  CountTokensResponse,
+  GenerateContentResponse,
+  GenerateContentParameters,
+  CountTokensParameters,
+  EmbedContentResponse,
+  EmbedContentParameters,
+  FinishReason,
+  Part,
+  Content,
+  Tool,
+  ToolListUnion,
+  CallableTool,
+  FunctionCall,
+  FunctionResponse,
+} from '@google/genai';
+import {
+  AuthType,
+  ContentGenerator,
+  ContentGeneratorConfig,
+} from './contentGenerator.js';
+import OpenAI from 'openai';
+import { logApiError, logApiResponse } from '../telemetry/loggers.js';
+import { ApiErrorEvent, ApiResponseEvent } from '../telemetry/types.js';
+import { Config } from '../config/config.js';
+import { openaiLogger } from '../utils/openaiLogger.js';
+import { safeJsonParse } from '../utils/safeJsonParse.js';
+
+// Extended types to support cache_control
+interface ChatCompletionContentPartTextWithCache
+  extends OpenAI.Chat.ChatCompletionContentPartText {
+  cache_control?: { type: 'ephemeral' };
+}
+
+type ChatCompletionContentPartWithCache =
+  | ChatCompletionContentPartTextWithCache
+  | OpenAI.Chat.ChatCompletionContentPartImage
+  | OpenAI.Chat.ChatCompletionContentPartRefusal;
+
+// OpenAI API type definitions for logging
+interface OpenAIToolCall {
+  id: string;
+  type: 'function';
+  function: {
+    name: string;
+    arguments: string;
+  };
+}
+
+interface OpenAIContentItem {
+  type: 'text';
+  text: string;
+  cache_control?: { type: 'ephemeral' };
+}
+
+interface OpenAIMessage {
+  role: 'system' | 'user' | 'assistant' | 'tool';
+  content: string | null | OpenAIContentItem[];
+  tool_calls?: OpenAIToolCall[];
+  tool_call_id?: string;
+}
+
+interface OpenAIUsage {
+  prompt_tokens: number;
+  completion_tokens: number;
+  total_tokens: number;
+  prompt_tokens_details?: {
+    cached_tokens?: number;
+  };
+}
+
+interface OpenAIChoice {
+  index: number;
+  message: OpenAIMessage;
+  finish_reason: string;
+}
+
+interface OpenAIResponseFormat {
+  id: string;
+  object: string;
+  created: number;
+  model: string;
+  choices: OpenAIChoice[];
+  usage?: OpenAIUsage;
+}
+
+export class OpenAIContentGenerator implements ContentGenerator {
+  protected client: OpenAI;
+  private model: string;
+  private contentGeneratorConfig: ContentGeneratorConfig;
+  private config: Config;
+  private streamingToolCalls: Map<
+    number,
+    {
+      id?: string;
+      name?: string;
+      arguments: string;
+    }
+  > = new Map();
+
+  constructor(
+    contentGeneratorConfig: ContentGeneratorConfig,
+    gcConfig: Config,
+  ) {
+    this.model = contentGeneratorConfig.model;
+    this.contentGeneratorConfig = contentGeneratorConfig;
+    this.config = gcConfig;
+
+    const version = gcConfig.getCliVersion() || 'unknown';
+    const userAgent = `QwenCode/${version} (${process.platform}; ${process.arch})`;
+
+    // Check if using OpenRouter and add required headers
+    const isOpenRouterProvider = this.isOpenRouterProvider();
+    const isDashScopeProvider = this.isDashScopeProvider();
+
+    const defaultHeaders = {
+      'User-Agent': userAgent,
+      ...(isOpenRouterProvider
+        ? {
+            'HTTP-Referer': 'https://github.com/QwenLM/qwen-code.git',
+            'X-Title': 'Qwen Code',
+          }
+        : isDashScopeProvider
+          ? {
+              'X-DashScope-CacheControl': 'enable',
+              'X-DashScope-UserAgent': userAgent,
+              'X-DashScope-AuthType': contentGeneratorConfig.authType,
+            }
+          : {}),
+    };
+
+    this.client = new OpenAI({
+      apiKey: contentGeneratorConfig.apiKey,
+      baseURL: contentGeneratorConfig.baseUrl,
+      timeout: contentGeneratorConfig.timeout ?? 120000,
+      maxRetries: contentGeneratorConfig.maxRetries ?? 3,
+      defaultHeaders,
+    });
+  }
+
+  /**
+   * Hook for subclasses to customize error handling behavior
+   * @param error The error that occurred
+   * @param request The original request
+   * @returns true if error logging should be suppressed, false otherwise
+   */
+  protected shouldSuppressErrorLogging(
+    _error: unknown,
+    _request: GenerateContentParameters,
+  ): boolean {
+    return false; // Default behavior: never suppress error logging
+  }
+
+  /**
+   * Check if an error is a timeout error
+   */
+  private isTimeoutError(error: unknown): boolean {
+    if (!error) return false;
+
+    const errorMessage =
+      error instanceof Error
+        ? error.message.toLowerCase()
+        : String(error).toLowerCase();
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const errorCode = (error as any)?.code;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const errorType = (error as any)?.type;
+
+    // Check for common timeout indicators
+    return (
+      errorMessage.includes('timeout') ||
+      errorMessage.includes('timed out') ||
+      errorMessage.includes('connection timeout') ||
+      errorMessage.includes('request timeout') ||
+      errorMessage.includes('read timeout') ||
+      errorMessage.includes('etimedout') || // Include ETIMEDOUT in message check
+      errorMessage.includes('esockettimedout') || // Include ESOCKETTIMEDOUT in message check
+      errorCode === 'ETIMEDOUT' ||
+      errorCode === 'ESOCKETTIMEDOUT' ||
+      errorType === 'timeout' ||
+      // OpenAI specific timeout indicators
+      errorMessage.includes('request timed out') ||
+      errorMessage.includes('deadline exceeded')
+    );
+  }
+
+  private isOpenRouterProvider(): boolean {
+    const baseURL = this.contentGeneratorConfig.baseUrl || '';
+    return baseURL.includes('openrouter.ai');
+  }
+
+  /**
+   * Determine if this is a DashScope provider.
+   * DashScope providers include QWEN_OAUTH auth type or specific DashScope base URLs.
+   *
+   * @returns true if this is a DashScope provider, false otherwise
+   */
+  private isDashScopeProvider(): boolean {
+    const authType = this.contentGeneratorConfig.authType;
+    const baseUrl = this.contentGeneratorConfig.baseUrl;
+
+    return (
+      authType === AuthType.QWEN_OAUTH ||
+      baseUrl === 'https://dashscope.aliyuncs.com/compatible-mode/v1' ||
+      baseUrl === 'https://dashscope-intl.aliyuncs.com/compatible-mode/v1'
+    );
+  }
+
+  /**
+   * Build metadata object for OpenAI API requests.
+   *
+   * @param userPromptId The user prompt ID to include in metadata
+   * @returns metadata object if shouldIncludeMetadata() returns true, undefined otherwise
+   */
+  private buildMetadata(
+    userPromptId: string,
+  ): { metadata: { sessionId?: string; promptId: string } } | undefined {
+    if (!this.isDashScopeProvider()) {
+      return undefined;
+    }
+
+    return {
+      metadata: {
+        sessionId: this.config.getSessionId?.(),
+        promptId: userPromptId,
+      },
+    };
+  }
+
+  private async buildCreateParams(
+    request: GenerateContentParameters,
+    userPromptId: string,
+    streaming: boolean = false,
+  ): Promise<Parameters<typeof this.client.chat.completions.create>[0]> {
+    let messages = this.convertToOpenAIFormat(request);
+
+    // Add cache control to system and last messages for DashScope providers
+    // Only add cache control to system message for non-streaming requests
+    if (this.isDashScopeProvider()) {
+      messages = this.addDashScopeCacheControl(
+        messages,
+        streaming ? 'both' : 'system',
+      );
+    }
+
+    // Build sampling parameters with clear priority:
+    // 1. Request-level parameters (highest priority)
+    // 2. Config-level sampling parameters (medium priority)
+    // 3. Default values (lowest priority)
+    const samplingParams = this.buildSamplingParameters(request);
+
+    const createParams: Parameters<
+      typeof this.client.chat.completions.create
+    >[0] = {
+      model: this.model,
+      messages,
+      ...samplingParams,
+      ...(this.buildMetadata(userPromptId) || {}),
+    };
+
+    if (request.config?.tools) {
+      createParams.tools = await this.convertGeminiToolsToOpenAI(
+        request.config.tools,
+      );
+    }
+
+    if (streaming) {
+      createParams.stream = true;
+      createParams.stream_options = { include_usage: true };
+    }
+
+    return createParams;
+  }
+
+  async generateContent(
+    request: GenerateContentParameters,
+    userPromptId: string,
+  ): Promise<GenerateContentResponse> {
+    const startTime = Date.now();
+    const createParams = await this.buildCreateParams(
+      request,
+      userPromptId,
+      false,
+    );
+
+    try {
+      const completion = (await this.client.chat.completions.create(
+        createParams,
+      )) as OpenAI.Chat.ChatCompletion;
+
+      const response = this.convertToGeminiFormat(completion);
+      const durationMs = Date.now() - startTime;
+
+      // Log API response event for UI telemetry
+      const responseEvent = new ApiResponseEvent(
+        response.responseId || 'unknown',
+        this.model,
+        durationMs,
+        userPromptId,
+        this.contentGeneratorConfig.authType,
+        response.usageMetadata,
+      );
+
+      logApiResponse(this.config, responseEvent);
+
+      // Log interaction if enabled
+      if (this.contentGeneratorConfig.enableOpenAILogging) {
+        const openaiRequest = createParams;
+        const openaiResponse = this.convertGeminiResponseToOpenAI(response);
+        await openaiLogger.logInteraction(openaiRequest, openaiResponse);
+      }
+
+      return response;
+    } catch (error) {
+      const durationMs = Date.now() - startTime;
+
+      // Identify timeout errors specifically
+      const isTimeoutError = this.isTimeoutError(error);
+      const errorMessage = isTimeoutError
+        ? `Request timeout after ${Math.round(durationMs / 1000)}s. Try reducing input length or increasing timeout in config.`
+        : error instanceof Error
+          ? error.message
+          : String(error);
+
+      // Log API error event for UI telemetry
+      const errorEvent = new ApiErrorEvent(
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        (error as any).requestID || 'unknown',
+        this.model,
+        errorMessage,
+        durationMs,
+        userPromptId,
+        this.contentGeneratorConfig.authType,
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        (error as any).type,
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        (error as any).code,
+      );
+      logApiError(this.config, errorEvent);
+
+      // Log error interaction if enabled
+      if (this.contentGeneratorConfig.enableOpenAILogging) {
+        await openaiLogger.logInteraction(
+          createParams,
+          undefined,
+          error as Error,
+        );
+      }
+
+      // Allow subclasses to suppress error logging for specific scenarios
+      if (!this.shouldSuppressErrorLogging(error, request)) {
+        console.error('OpenAI API Error:', errorMessage);
+      }
+
+      // Provide helpful timeout-specific error message
+      if (isTimeoutError) {
+        throw new Error(
+          `${errorMessage}\n\nTroubleshooting tips:\n` +
+            `- Reduce input length or complexity\n` +
+            `- Increase timeout in config: contentGenerator.timeout\n` +
+            `- Check network connectivity\n` +
+            `- Consider using streaming mode for long responses`,
+        );
+      }
+
+      throw error;
+    }
+  }
+
+  async generateContentStream(
+    request: GenerateContentParameters,
+    userPromptId: string,
+  ): Promise<AsyncGenerator<GenerateContentResponse>> {
+    const startTime = Date.now();
+    const createParams = await this.buildCreateParams(
+      request,
+      userPromptId,
+      true,
+    );
+
+    try {
+      const stream = (await this.client.chat.completions.create(
+        createParams,
+      )) as AsyncIterable<OpenAI.Chat.ChatCompletionChunk>;
+
+      const originalStream = this.streamGenerator(stream);
+
+      // Collect all responses for final logging (don't log during streaming)
+      const responses: GenerateContentResponse[] = [];
+
+      // Return a new generator that both yields responses and collects them
+      const wrappedGenerator = async function* (this: OpenAIContentGenerator) {
+        try {
+          for await (const response of originalStream) {
+            responses.push(response);
+            yield response;
+          }
+
+          const durationMs = Date.now() - startTime;
+
+          // Get final usage metadata from the last response that has it
+          const finalUsageMetadata = responses
+            .slice()
+            .reverse()
+            .find((r) => r.usageMetadata)?.usageMetadata;
+
+          // Log API response event for UI telemetry
+          const responseEvent = new ApiResponseEvent(
+            responses[responses.length - 1]?.responseId || 'unknown',
+            this.model,
+            durationMs,
+            userPromptId,
+            this.contentGeneratorConfig.authType,
+            finalUsageMetadata,
+          );
+
+          logApiResponse(this.config, responseEvent);
+
+          // Log interaction if enabled (same as generateContent method)
+          if (this.contentGeneratorConfig.enableOpenAILogging) {
+            const openaiRequest = createParams;
+            // For streaming, we combine all responses into a single response for logging
+            const combinedResponse =
+              this.combineStreamResponsesForLogging(responses);
+            const openaiResponse =
+              this.convertGeminiResponseToOpenAI(combinedResponse);
+            await openaiLogger.logInteraction(openaiRequest, openaiResponse);
+          }
+        } catch (error) {
+          const durationMs = Date.now() - startTime;
+
+          // Identify timeout errors specifically for streaming
+          const isTimeoutError = this.isTimeoutError(error);
+          const errorMessage = isTimeoutError
+            ? `Streaming request timeout after ${Math.round(durationMs / 1000)}s. Try reducing input length or increasing timeout in config.`
+            : error instanceof Error
+              ? error.message
+              : String(error);
+
+          // Log API error event for UI telemetry
+          const errorEvent = new ApiErrorEvent(
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            (error as any).requestID || 'unknown',
+            this.model,
+            errorMessage,
+            durationMs,
+            userPromptId,
+            this.contentGeneratorConfig.authType,
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            (error as any).type,
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            (error as any).code,
+          );
+          logApiError(this.config, errorEvent);
+
+          // Log error interaction if enabled
+          if (this.contentGeneratorConfig.enableOpenAILogging) {
+            await openaiLogger.logInteraction(
+              createParams,
+              undefined,
+              error as Error,
+            );
+          }
+
+          // Provide helpful timeout-specific error message for streaming
+          if (isTimeoutError) {
+            throw new Error(
+              `${errorMessage}\n\nStreaming timeout troubleshooting:\n` +
+                `- Reduce input length or complexity\n` +
+                `- Increase timeout in config: contentGenerator.timeout\n` +
+                `- Check network stability for streaming connections\n` +
+                `- Consider using non-streaming mode for very long inputs`,
+            );
+          }
+
+          throw error;
+        }
+      }.bind(this);
+
+      return wrappedGenerator();
+    } catch (error) {
+      const durationMs = Date.now() - startTime;
+
+      // Identify timeout errors specifically for streaming setup
+      const isTimeoutError = this.isTimeoutError(error);
+      const errorMessage = isTimeoutError
+        ? `Streaming setup timeout after ${Math.round(durationMs / 1000)}s. Try reducing input length or increasing timeout in config.`
+        : error instanceof Error
+          ? error.message
+          : String(error);
+
+      // Log API error event for UI telemetry
+      const errorEvent = new ApiErrorEvent(
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        (error as any).requestID || 'unknown',
+        this.model,
+        errorMessage,
+        durationMs,
+        userPromptId,
+        this.contentGeneratorConfig.authType,
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        (error as any).type,
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        (error as any).code,
+      );
+      logApiError(this.config, errorEvent);
+
+      // Allow subclasses to suppress error logging for specific scenarios
+      if (!this.shouldSuppressErrorLogging(error, request)) {
+        console.error('OpenAI API Streaming Error:', errorMessage);
+      }
+
+      // Provide helpful timeout-specific error message for streaming setup
+      if (isTimeoutError) {
+        throw new Error(
+          `${errorMessage}\n\nStreaming setup timeout troubleshooting:\n` +
+            `- Reduce input length or complexity\n` +
+            `- Increase timeout in config: contentGenerator.timeout\n` +
+            `- Check network connectivity and firewall settings\n` +
+            `- Consider using non-streaming mode for very long inputs`,
+        );
+      }
+
+      throw error;
+    }
+  }
+
+  private async *streamGenerator(
+    stream: AsyncIterable<OpenAI.Chat.ChatCompletionChunk>,
+  ): AsyncGenerator<GenerateContentResponse> {
+    // Reset the accumulator for each new stream
+    this.streamingToolCalls.clear();
+
+    for await (const chunk of stream) {
+      const response = this.convertStreamChunkToGeminiFormat(chunk);
+
+      // Ignore empty responses, which would cause problems with downstream code
+      // that expects a valid response.
+      if (
+        response.candidates?.[0]?.content?.parts?.length === 0 &&
+        !response.usageMetadata
+      ) {
+        continue;
+      }
+
+      yield response;
+    }
+  }
+
+  /**
+   * Combine streaming responses for logging purposes
+   */
+  private combineStreamResponsesForLogging(
+    responses: GenerateContentResponse[],
+  ): GenerateContentResponse {
+    if (responses.length === 0) {
+      return new GenerateContentResponse();
+    }
+
+    const lastResponse = responses[responses.length - 1];
+
+    // Find the last response with usage metadata
+    const finalUsageMetadata = responses
+      .slice()
+      .reverse()
+      .find((r) => r.usageMetadata)?.usageMetadata;
+
+    // Combine all text content from the stream
+    const combinedParts: Part[] = [];
+    let combinedText = '';
+    const functionCalls: Part[] = [];
+
+    for (const response of responses) {
+      if (response.candidates?.[0]?.content?.parts) {
+        for (const part of response.candidates[0].content.parts) {
+          if ('text' in part && part.text) {
+            combinedText += part.text;
+          } else if ('functionCall' in part && part.functionCall) {
+            functionCalls.push(part);
+          }
+        }
+      }
+    }
+
+    // Add combined text if any
+    if (combinedText) {
+      combinedParts.push({ text: combinedText });
+    }
+
+    // Add function calls
+    combinedParts.push(...functionCalls);
+
+    // Create combined response
+    const combinedResponse = new GenerateContentResponse();
+    combinedResponse.candidates = [
+      {
+        content: {
+          parts: combinedParts,
+          role: 'model' as const,
+        },
+        finishReason:
+          responses[responses.length - 1]?.candidates?.[0]?.finishReason ||
+          FinishReason.FINISH_REASON_UNSPECIFIED,
+        index: 0,
+        safetyRatings: [],
+      },
+    ];
+    combinedResponse.responseId = lastResponse?.responseId;
+    combinedResponse.createTime = lastResponse?.createTime;
+    combinedResponse.modelVersion = this.model;
+    combinedResponse.promptFeedback = { safetyRatings: [] };
+    combinedResponse.usageMetadata = finalUsageMetadata;
+
+    return combinedResponse;
+  }
+
+  async countTokens(
+    request: CountTokensParameters,
+  ): Promise<CountTokensResponse> {
+    // Use tiktoken for accurate token counting
+    const content = JSON.stringify(request.contents);
+    let totalTokens = 0;
+
+    try {
+      const { get_encoding } = await import('tiktoken');
+      const encoding = get_encoding('cl100k_base'); // GPT-4 encoding, but estimate for qwen
+      totalTokens = encoding.encode(content).length;
+      encoding.free();
+    } catch (error) {
+      console.warn(
+        'Failed to load tiktoken, falling back to character approximation:',
+        error,
+      );
+      // Fallback: rough approximation using character count
+      totalTokens = Math.ceil(content.length / 4); // Rough estimate: 1 token ≈ 4 characters
+    }
+
+    return {
+      totalTokens,
+    };
+  }
+
+  async embedContent(
+    request: EmbedContentParameters,
+  ): Promise<EmbedContentResponse> {
+    // Extract text from contents
+    let text = '';
+    if (Array.isArray(request.contents)) {
+      text = request.contents
+        .map((content) => {
+          if (typeof content === 'string') return content;
+          if ('parts' in content && content.parts) {
+            return content.parts
+              .map((part) =>
+                typeof part === 'string'
+                  ? part
+                  : 'text' in part
+                    ? (part as { text?: string }).text || ''
+                    : '',
+              )
+              .join(' ');
+          }
+          return '';
+        })
+        .join(' ');
+    } else if (request.contents) {
+      if (typeof request.contents === 'string') {
+        text = request.contents;
+      } else if ('parts' in request.contents && request.contents.parts) {
+        text = request.contents.parts
+          .map((part: Part) =>
+            typeof part === 'string' ? part : 'text' in part ? part.text : '',
+          )
+          .join(' ');
+      }
+    }
+
+    try {
+      const embedding = await this.client.embeddings.create({
+        model: 'text-embedding-ada-002', // Default embedding model
+        input: text,
+      });
+
+      return {
+        embeddings: [
+          {
+            values: embedding.data[0].embedding,
+          },
+        ],
+      };
+    } catch (error) {
+      console.error('OpenAI API Embedding Error:', error);
+      throw new Error(
+        `OpenAI API error: ${error instanceof Error ? error.message : String(error)}`,
+      );
+    }
+  }
+
+  private convertGeminiParametersToOpenAI(
+    parameters: Record<string, unknown>,
+  ): Record<string, unknown> | undefined {
+    if (!parameters || typeof parameters !== 'object') {
+      return parameters;
+    }
+
+    const converted = JSON.parse(JSON.stringify(parameters));
+
+    const convertTypes = (obj: unknown): unknown => {
+      if (typeof obj !== 'object' || obj === null) {
+        return obj;
+      }
+
+      if (Array.isArray(obj)) {
+        return obj.map(convertTypes);
+      }
+
+      const result: Record<string, unknown> = {};
+      for (const [key, value] of Object.entries(obj)) {
+        if (key === 'type' && typeof value === 'string') {
+          // Convert Gemini types to OpenAI JSON Schema types
+          const lowerValue = value.toLowerCase();
+          if (lowerValue === 'integer') {
+            result[key] = 'integer';
+          } else if (lowerValue === 'number') {
+            result[key] = 'number';
+          } else {
+            result[key] = lowerValue;
+          }
+        } else if (
+          key === 'minimum' ||
+          key === 'maximum' ||
+          key === 'multipleOf'
+        ) {
+          // Ensure numeric constraints are actual numbers, not strings
+          if (typeof value === 'string' && !isNaN(Number(value))) {
+            result[key] = Number(value);
+          } else {
+            result[key] = value;
+          }
+        } else if (
+          key === 'minLength' ||
+          key === 'maxLength' ||
+          key === 'minItems' ||
+          key === 'maxItems'
+        ) {
+          // Ensure length constraints are integers, not strings
+          if (typeof value === 'string' && !isNaN(Number(value))) {
+            result[key] = parseInt(value, 10);
+          } else {
+            result[key] = value;
+          }
+        } else if (typeof value === 'object') {
+          result[key] = convertTypes(value);
+        } else {
+          result[key] = value;
+        }
+      }
+      return result;
+    };
+
+    return convertTypes(converted) as Record<string, unknown> | undefined;
+  }
+
+  /**
+   * Converts Gemini tools to OpenAI format for API compatibility.
+   * Handles both Gemini tools (using 'parameters' field) and MCP tools (using 'parametersJsonSchema' field).
+   *
+   * Gemini tools use a custom parameter format that needs conversion to OpenAI JSON Schema format.
+   * MCP tools already use JSON Schema format in the parametersJsonSchema field and can be used directly.
+   *
+   * @param geminiTools - Array of Gemini tools to convert
+   * @returns Promise resolving to array of OpenAI-compatible tools
+   */
+  private async convertGeminiToolsToOpenAI(
+    geminiTools: ToolListUnion,
+  ): Promise<OpenAI.Chat.ChatCompletionTool[]> {
+    const openAITools: OpenAI.Chat.ChatCompletionTool[] = [];
+
+    for (const tool of geminiTools) {
+      let actualTool: Tool;
+
+      // Handle CallableTool vs Tool
+      if ('tool' in tool) {
+        // This is a CallableTool
+        actualTool = await (tool as CallableTool).tool();
+      } else {
+        // This is already a Tool
+        actualTool = tool as Tool;
+      }
+
+      if (actualTool.functionDeclarations) {
+        for (const func of actualTool.functionDeclarations) {
+          if (func.name && func.description) {
+            let parameters: Record<string, unknown> | undefined;
+
+            // Handle both Gemini tools (parameters) and MCP tools (parametersJsonSchema)
+            if (func.parametersJsonSchema) {
+              // MCP tool format - use parametersJsonSchema directly
+              if (func.parametersJsonSchema) {
+                // Create a shallow copy to avoid mutating the original object
+                const paramsCopy = {
+                  ...(func.parametersJsonSchema as Record<string, unknown>),
+                };
+                parameters = paramsCopy;
+              }
+            } else if (func.parameters) {
+              // Gemini tool format - convert parameters to OpenAI format
+              parameters = this.convertGeminiParametersToOpenAI(
+                func.parameters as Record<string, unknown>,
+              );
+            }
+
+            openAITools.push({
+              type: 'function',
+              function: {
+                name: func.name,
+                description: func.description,
+                parameters,
+              },
+            });
+          }
+        }
+      }
+    }
+
+    // console.log(
+    //   'OpenAI Tools Parameters:',
+    //   JSON.stringify(openAITools, null, 2),
+    // );
+    return openAITools;
+  }
+
+  private convertToOpenAIFormat(
+    request: GenerateContentParameters,
+  ): OpenAI.Chat.ChatCompletionMessageParam[] {
+    const messages: OpenAI.Chat.ChatCompletionMessageParam[] = [];
+
+    // Handle system instruction from config
+    if (request.config?.systemInstruction) {
+      const systemInstruction = request.config.systemInstruction;
+      let systemText = '';
+
+      if (Array.isArray(systemInstruction)) {
+        systemText = systemInstruction
+          .map((content) => {
+            if (typeof content === 'string') return content;
+            if ('parts' in content) {
+              const contentObj = content as Content;
+              return (
+                contentObj.parts
+                  ?.map((p: Part) =>
+                    typeof p === 'string' ? p : 'text' in p ? p.text : '',
+                  )
+                  .join('\n') || ''
+              );
+            }
+            return '';
+          })
+          .join('\n');
+      } else if (typeof systemInstruction === 'string') {
+        systemText = systemInstruction;
+      } else if (
+        typeof systemInstruction === 'object' &&
+        'parts' in systemInstruction
+      ) {
+        const systemContent = systemInstruction as Content;
+        systemText =
+          systemContent.parts
+            ?.map((p: Part) =>
+              typeof p === 'string' ? p : 'text' in p ? p.text : '',
+            )
+            .join('\n') || '';
+      }
+
+      if (systemText) {
+        messages.push({
+          role: 'system' as const,
+          content: systemText,
+        });
+      }
+    }
+
+    // Handle contents
+    if (Array.isArray(request.contents)) {
+      for (const content of request.contents) {
+        if (typeof content === 'string') {
+          messages.push({ role: 'user' as const, content });
+        } else if ('role' in content && 'parts' in content) {
+          // Check if this content has function calls or responses
+          const functionCalls: FunctionCall[] = [];
+          const functionResponses: FunctionResponse[] = [];
+          const textParts: string[] = [];
+
+          for (const part of content.parts || []) {
+            if (typeof part === 'string') {
+              textParts.push(part);
+            } else if ('text' in part && part.text) {
+              textParts.push(part.text);
+            } else if ('functionCall' in part && part.functionCall) {
+              functionCalls.push(part.functionCall);
+            } else if ('functionResponse' in part && part.functionResponse) {
+              functionResponses.push(part.functionResponse);
+            }
+          }
+
+          // Handle function responses (tool results)
+          if (functionResponses.length > 0) {
+            for (const funcResponse of functionResponses) {
+              messages.push({
+                role: 'tool' as const,
+                tool_call_id: funcResponse.id || '',
+                content:
+                  typeof funcResponse.response === 'string'
+                    ? funcResponse.response
+                    : JSON.stringify(funcResponse.response),
+              });
+            }
+          }
+          // Handle model messages with function calls
+          else if (content.role === 'model' && functionCalls.length > 0) {
+            const toolCalls = functionCalls.map((fc, index) => ({
+              id: fc.id || `call_${index}`,
+              type: 'function' as const,
+              function: {
+                name: fc.name || '',
+                arguments: JSON.stringify(fc.args || {}),
+              },
+            }));
+
+            messages.push({
+              role: 'assistant' as const,
+              content: textParts.join('') || null,
+              tool_calls: toolCalls,
+            });
+          }
+          // Handle regular text messages
+          else {
+            const role =
+              content.role === 'model'
+                ? ('assistant' as const)
+                : ('user' as const);
+            const text = textParts.join('');
+            if (text) {
+              messages.push({ role, content: text });
+            }
+          }
+        }
+      }
+    } else if (request.contents) {
+      if (typeof request.contents === 'string') {
+        messages.push({ role: 'user' as const, content: request.contents });
+      } else if ('role' in request.contents && 'parts' in request.contents) {
+        const content = request.contents;
+        const role =
+          content.role === 'model' ? ('assistant' as const) : ('user' as const);
+        const text =
+          content.parts
+            ?.map((p: Part) =>
+              typeof p === 'string' ? p : 'text' in p ? p.text : '',
+            )
+            .join('\n') || '';
+        messages.push({ role, content: text });
+      }
+    }
+
+    // Clean up orphaned tool calls and merge consecutive assistant messages
+    const cleanedMessages = this.cleanOrphanedToolCalls(messages);
+    const mergedMessages =
+      this.mergeConsecutiveAssistantMessages(cleanedMessages);
+
+    return mergedMessages;
+  }
+
+  /**
+   * Add cache control flag to specified message(s) for DashScope providers
+   */
+  private addDashScopeCacheControl(
+    messages: OpenAI.Chat.ChatCompletionMessageParam[],
+    target: 'system' | 'last' | 'both' = 'both',
+  ): OpenAI.Chat.ChatCompletionMessageParam[] {
+    if (!this.isDashScopeProvider() || messages.length === 0) {
+      return messages;
+    }
+
+    let updatedMessages = [...messages];
+
+    // Add cache control to system message if requested
+    if (target === 'system' || target === 'both') {
+      updatedMessages = this.addCacheControlToMessage(
+        updatedMessages,
+        'system',
+      );
+    }
+
+    // Add cache control to last message if requested
+    if (target === 'last' || target === 'both') {
+      updatedMessages = this.addCacheControlToMessage(updatedMessages, 'last');
+    }
+
+    return updatedMessages;
+  }
+
+  /**
+   * Helper method to add cache control to a specific message
+   */
+  private addCacheControlToMessage(
+    messages: OpenAI.Chat.ChatCompletionMessageParam[],
+    target: 'system' | 'last',
+  ): OpenAI.Chat.ChatCompletionMessageParam[] {
+    const updatedMessages = [...messages];
+    let messageIndex: number;
+
+    if (target === 'system') {
+      // Find the first system message
+      messageIndex = messages.findIndex((msg) => msg.role === 'system');
+      if (messageIndex === -1) {
+        return updatedMessages;
+      }
+    } else {
+      // Get the last message
+      messageIndex = messages.length - 1;
+    }
+
+    const message = updatedMessages[messageIndex];
+
+    // Only process messages that have content
+    if ('content' in message && message.content !== null) {
+      if (typeof message.content === 'string') {
+        // Convert string content to array format with cache control
+        const messageWithArrayContent = {
+          ...message,
+          content: [
+            {
+              type: 'text',
+              text: message.content,
+              cache_control: { type: 'ephemeral' },
+            } as ChatCompletionContentPartTextWithCache,
+          ],
+        };
+        updatedMessages[messageIndex] =
+          messageWithArrayContent as OpenAI.Chat.ChatCompletionMessageParam;
+      } else if (Array.isArray(message.content)) {
+        // If content is already an array, add cache_control to the last item
+        const contentArray = [
+          ...message.content,
+        ] as ChatCompletionContentPartWithCache[];
+        if (contentArray.length > 0) {
+          const lastItem = contentArray[contentArray.length - 1];
+          if (lastItem.type === 'text') {
+            // Add cache_control to the last text item
+            contentArray[contentArray.length - 1] = {
+              ...lastItem,
+              cache_control: { type: 'ephemeral' },
+            } as ChatCompletionContentPartTextWithCache;
+          } else {
+            // If the last item is not text, add a new text item with cache_control
+            contentArray.push({
+              type: 'text',
+              text: '',
+              cache_control: { type: 'ephemeral' },
+            } as ChatCompletionContentPartTextWithCache);
+          }
+
+          const messageWithCache = {
+            ...message,
+            content: contentArray,
+          };
+          updatedMessages[messageIndex] =
+            messageWithCache as OpenAI.Chat.ChatCompletionMessageParam;
+        }
+      }
+    }
+
+    return updatedMessages;
+  }
+
+  /**
+   * Clean up orphaned tool calls from message history to prevent OpenAI API errors
+   */
+  private cleanOrphanedToolCalls(
+    messages: OpenAI.Chat.ChatCompletionMessageParam[],
+  ): OpenAI.Chat.ChatCompletionMessageParam[] {
+    const cleaned: OpenAI.Chat.ChatCompletionMessageParam[] = [];
+    const toolCallIds = new Set<string>();
+    const toolResponseIds = new Set<string>();
+
+    // First pass: collect all tool call IDs and tool response IDs
+    for (const message of messages) {
+      if (
+        message.role === 'assistant' &&
+        'tool_calls' in message &&
+        message.tool_calls
+      ) {
+        for (const toolCall of message.tool_calls) {
+          if (toolCall.id) {
+            toolCallIds.add(toolCall.id);
+          }
+        }
+      } else if (
+        message.role === 'tool' &&
+        'tool_call_id' in message &&
+        message.tool_call_id
+      ) {
+        toolResponseIds.add(message.tool_call_id);
+      }
+    }
+
+    // Second pass: filter out orphaned messages
+    for (const message of messages) {
+      if (
+        message.role === 'assistant' &&
+        'tool_calls' in message &&
+        message.tool_calls
+      ) {
+        // Filter out tool calls that don't have corresponding responses
+        const validToolCalls = message.tool_calls.filter(
+          (toolCall) => toolCall.id && toolResponseIds.has(toolCall.id),
+        );
+
+        if (validToolCalls.length > 0) {
+          // Keep the message but only with valid tool calls
+          const cleanedMessage = { ...message };
+          (
+            cleanedMessage as OpenAI.Chat.ChatCompletionMessageParam & {
+              tool_calls?: OpenAI.Chat.ChatCompletionMessageToolCall[];
+            }
+          ).tool_calls = validToolCalls;
+          cleaned.push(cleanedMessage);
+        } else if (
+          typeof message.content === 'string' &&
+          message.content.trim()
+        ) {
+          // Keep the message if it has text content, but remove tool calls
+          const cleanedMessage = { ...message };
+          delete (
+            cleanedMessage as OpenAI.Chat.ChatCompletionMessageParam & {
+              tool_calls?: OpenAI.Chat.ChatCompletionMessageToolCall[];
+            }
+          ).tool_calls;
+          cleaned.push(cleanedMessage);
+        }
+        // If no valid tool calls and no content, skip the message entirely
+      } else if (
+        message.role === 'tool' &&
+        'tool_call_id' in message &&
+        message.tool_call_id
+      ) {
+        // Only keep tool responses that have corresponding tool calls
+        if (toolCallIds.has(message.tool_call_id)) {
+          cleaned.push(message);
+        }
+      } else {
+        // Keep all other messages as-is
+        cleaned.push(message);
+      }
+    }
+
+    // Final validation: ensure every assistant message with tool_calls has corresponding tool responses
+    const finalCleaned: OpenAI.Chat.ChatCompletionMessageParam[] = [];
+    const finalToolCallIds = new Set<string>();
+
+    // Collect all remaining tool call IDs
+    for (const message of cleaned) {
+      if (
+        message.role === 'assistant' &&
+        'tool_calls' in message &&
+        message.tool_calls
+      ) {
+        for (const toolCall of message.tool_calls) {
+          if (toolCall.id) {
+            finalToolCallIds.add(toolCall.id);
+          }
+        }
+      }
+    }
+
+    // Verify all tool calls have responses
+    const finalToolResponseIds = new Set<string>();
+    for (const message of cleaned) {
+      if (
+        message.role === 'tool' &&
+        'tool_call_id' in message &&
+        message.tool_call_id
+      ) {
+        finalToolResponseIds.add(message.tool_call_id);
+      }
+    }
+
+    // Remove any remaining orphaned tool calls
+    for (const message of cleaned) {
+      if (
+        message.role === 'assistant' &&
+        'tool_calls' in message &&
+        message.tool_calls
+      ) {
+        const finalValidToolCalls = message.tool_calls.filter(
+          (toolCall) => toolCall.id && finalToolResponseIds.has(toolCall.id),
+        );
+
+        if (finalValidToolCalls.length > 0) {
+          const cleanedMessage = { ...message };
+          (
+            cleanedMessage as OpenAI.Chat.ChatCompletionMessageParam & {
+              tool_calls?: OpenAI.Chat.ChatCompletionMessageToolCall[];
+            }
+          ).tool_calls = finalValidToolCalls;
+          finalCleaned.push(cleanedMessage);
+        } else if (
+          typeof message.content === 'string' &&
+          message.content.trim()
+        ) {
+          const cleanedMessage = { ...message };
+          delete (
+            cleanedMessage as OpenAI.Chat.ChatCompletionMessageParam & {
+              tool_calls?: OpenAI.Chat.ChatCompletionMessageToolCall[];
+            }
+          ).tool_calls;
+          finalCleaned.push(cleanedMessage);
+        }
+      } else {
+        finalCleaned.push(message);
+      }
+    }
+
+    return finalCleaned;
+  }
+
+  /**
+   * Merge consecutive assistant messages to combine split text and tool calls
+   */
+  private mergeConsecutiveAssistantMessages(
+    messages: OpenAI.Chat.ChatCompletionMessageParam[],
+  ): OpenAI.Chat.ChatCompletionMessageParam[] {
+    const merged: OpenAI.Chat.ChatCompletionMessageParam[] = [];
+
+    for (const message of messages) {
+      if (message.role === 'assistant' && merged.length > 0) {
+        const lastMessage = merged[merged.length - 1];
+
+        // If the last message is also an assistant message, merge them
+        if (lastMessage.role === 'assistant') {
+          // Combine content
+          const combinedContent = [
+            typeof lastMessage.content === 'string' ? lastMessage.content : '',
+            typeof message.content === 'string' ? message.content : '',
+          ]
+            .filter(Boolean)
+            .join('');
+
+          // Combine tool calls
+          const lastToolCalls =
+            'tool_calls' in lastMessage ? lastMessage.tool_calls || [] : [];
+          const currentToolCalls =
+            'tool_calls' in message ? message.tool_calls || [] : [];
+          const combinedToolCalls = [...lastToolCalls, ...currentToolCalls];
+
+          // Update the last message with combined data
+          (
+            lastMessage as OpenAI.Chat.ChatCompletionMessageParam & {
+              content: string | null;
+              tool_calls?: OpenAI.Chat.ChatCompletionMessageToolCall[];
+            }
+          ).content = combinedContent || null;
+          if (combinedToolCalls.length > 0) {
+            (
+              lastMessage as OpenAI.Chat.ChatCompletionMessageParam & {
+                content: string | null;
+                tool_calls?: OpenAI.Chat.ChatCompletionMessageToolCall[];
+              }
+            ).tool_calls = combinedToolCalls;
+          }
+
+          continue; // Skip adding the current message since it's been merged
+        }
+      }
+
+      // Add the message as-is if no merging is needed
+      merged.push(message);
+    }
+
+    return merged;
+  }
+
+  private convertToGeminiFormat(
+    openaiResponse: OpenAI.Chat.ChatCompletion,
+  ): GenerateContentResponse {
+    const choice = openaiResponse.choices[0];
+    const response = new GenerateContentResponse();
+
+    const parts: Part[] = [];
+
+    // Handle text content
+    if (choice.message.content) {
+      parts.push({ text: choice.message.content });
+    }
+
+    // Handle tool calls
+    if (choice.message.tool_calls) {
+      for (const toolCall of choice.message.tool_calls) {
+        if (toolCall.function) {
+          let args: Record<string, unknown> = {};
+          if (toolCall.function.arguments) {
+            args = safeJsonParse(toolCall.function.arguments, {});
+          }
+
+          parts.push({
+            functionCall: {
+              id: toolCall.id,
+              name: toolCall.function.name,
+              args,
+            },
+          });
+        }
+      }
+    }
+
+    response.responseId = openaiResponse.id;
+    response.createTime = openaiResponse.created
+      ? openaiResponse.created.toString()
+      : new Date().getTime().toString();
+
+    response.candidates = [
+      {
+        content: {
+          parts,
+          role: 'model' as const,
+        },
+        finishReason: this.mapFinishReason(choice.finish_reason || 'stop'),
+        index: 0,
+        safetyRatings: [],
+      },
+    ];
+
+    response.modelVersion = this.model;
+    response.promptFeedback = { safetyRatings: [] };
+
+    // Add usage metadata if available
+    if (openaiResponse.usage) {
+      const usage = openaiResponse.usage as OpenAIUsage;
+
+      const promptTokens = usage.prompt_tokens || 0;
+      const completionTokens = usage.completion_tokens || 0;
+      const totalTokens = usage.total_tokens || 0;
+      const cachedTokens = usage.prompt_tokens_details?.cached_tokens || 0;
+
+      // If we only have total tokens but no breakdown, estimate the split
+      // Typically input is ~70% and output is ~30% for most conversations
+      let finalPromptTokens = promptTokens;
+      let finalCompletionTokens = completionTokens;
+
+      if (totalTokens > 0 && promptTokens === 0 && completionTokens === 0) {
+        // Estimate: assume 70% input, 30% output
+        finalPromptTokens = Math.round(totalTokens * 0.7);
+        finalCompletionTokens = Math.round(totalTokens * 0.3);
+      }
+
+      response.usageMetadata = {
+        promptTokenCount: finalPromptTokens,
+        candidatesTokenCount: finalCompletionTokens,
+        totalTokenCount: totalTokens,
+        cachedContentTokenCount: cachedTokens,
+      };
+    }
+
+    return response;
+  }
+
+  private convertStreamChunkToGeminiFormat(
+    chunk: OpenAI.Chat.ChatCompletionChunk,
+  ): GenerateContentResponse {
+    const choice = chunk.choices?.[0];
+    const response = new GenerateContentResponse();
+
+    if (choice) {
+      const parts: Part[] = [];
+
+      // Handle text content
+      if (choice.delta?.content) {
+        if (typeof choice.delta.content === 'string') {
+          parts.push({ text: choice.delta.content });
+        }
+      }
+
+      // Handle tool calls - only accumulate during streaming, emit when complete
+      if (choice.delta?.tool_calls) {
+        for (const toolCall of choice.delta.tool_calls) {
+          const index = toolCall.index ?? 0;
+
+          // Get or create the tool call accumulator for this index
+          let accumulatedCall = this.streamingToolCalls.get(index);
+          if (!accumulatedCall) {
+            accumulatedCall = { arguments: '' };
+            this.streamingToolCalls.set(index, accumulatedCall);
+          }
+
+          // Update accumulated data
+          if (toolCall.id) {
+            accumulatedCall.id = toolCall.id;
+          }
+          if (toolCall.function?.name) {
+            // If this is a new function name, reset the arguments
+            if (accumulatedCall.name !== toolCall.function.name) {
+              accumulatedCall.arguments = '';
+            }
+            accumulatedCall.name = toolCall.function.name;
+          }
+          if (toolCall.function?.arguments) {
+            // Check if we already have a complete JSON object
+            const currentArgs = accumulatedCall.arguments;
+            const newArgs = toolCall.function.arguments;
+
+            // If current arguments already form a complete JSON and new arguments start a new object,
+            // this indicates a new tool call with the same name
+            let shouldReset = false;
+            if (currentArgs && newArgs.trim().startsWith('{')) {
+              try {
+                JSON.parse(currentArgs);
+                // If we can parse current arguments as complete JSON and new args start with {,
+                // this is likely a new tool call
+                shouldReset = true;
+              } catch {
+                // Current arguments are not complete JSON, continue accumulating
+              }
+            }
+
+            if (shouldReset) {
+              accumulatedCall.arguments = newArgs;
+            } else {
+              accumulatedCall.arguments += newArgs;
+            }
+          }
+        }
+      }
+
+      // Only emit function calls when streaming is complete (finish_reason is present)
+      if (choice.finish_reason) {
+        for (const [, accumulatedCall] of this.streamingToolCalls) {
+          // TODO: Add back id once we have a way to generate tool_call_id from the VLLM parser.
+          // if (accumulatedCall.id && accumulatedCall.name) {
+          if (accumulatedCall.name) {
+            let args: Record<string, unknown> = {};
+            if (accumulatedCall.arguments) {
+              args = safeJsonParse(accumulatedCall.arguments, {});
+            }
+
+            parts.push({
+              functionCall: {
+                id:
+                  accumulatedCall.id ||
+                  `call_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`,
+                name: accumulatedCall.name,
+                args,
+              },
+            });
+          }
+        }
+        // Clear all accumulated tool calls
+        this.streamingToolCalls.clear();
+      }
+
+      response.candidates = [
+        {
+          content: {
+            parts,
+            role: 'model' as const,
+          },
+          finishReason: choice.finish_reason
+            ? this.mapFinishReason(choice.finish_reason)
+            : FinishReason.FINISH_REASON_UNSPECIFIED,
+          index: 0,
+          safetyRatings: [],
+        },
+      ];
+    } else {
+      response.candidates = [];
+    }
+
+    response.responseId = chunk.id;
+    response.createTime = chunk.created
+      ? chunk.created.toString()
+      : new Date().getTime().toString();
+
+    response.modelVersion = this.model;
+    response.promptFeedback = { safetyRatings: [] };
+
+    // Add usage metadata if available in the chunk
+    if (chunk.usage) {
+      const usage = chunk.usage as OpenAIUsage;
+
+      const promptTokens = usage.prompt_tokens || 0;
+      const completionTokens = usage.completion_tokens || 0;
+      const totalTokens = usage.total_tokens || 0;
+      const cachedTokens = usage.prompt_tokens_details?.cached_tokens || 0;
+
+      // If we only have total tokens but no breakdown, estimate the split
+      // Typically input is ~70% and output is ~30% for most conversations
+      let finalPromptTokens = promptTokens;
+      let finalCompletionTokens = completionTokens;
+
+      if (totalTokens > 0 && promptTokens === 0 && completionTokens === 0) {
+        // Estimate: assume 70% input, 30% output
+        finalPromptTokens = Math.round(totalTokens * 0.7);
+        finalCompletionTokens = Math.round(totalTokens * 0.3);
+      }
+
+      response.usageMetadata = {
+        promptTokenCount: finalPromptTokens,
+        candidatesTokenCount: finalCompletionTokens,
+        totalTokenCount: totalTokens,
+        cachedContentTokenCount: cachedTokens,
+      };
+    }
+
+    return response;
+  }
+
+  /**
+   * Build sampling parameters with clear priority:
+   * 1. Config-level sampling parameters (highest priority)
+   * 2. Request-level parameters (medium priority)
+   * 3. Default values (lowest priority)
+   */
+  private buildSamplingParameters(
+    request: GenerateContentParameters,
+  ): Record<string, unknown> {
+    const configSamplingParams = this.contentGeneratorConfig.samplingParams;
+
+    const params = {
+      // Temperature: config > request > default
+      temperature:
+        configSamplingParams?.temperature !== undefined
+          ? configSamplingParams.temperature
+          : request.config?.temperature !== undefined
+            ? request.config.temperature
+            : 0.0,
+
+      // Max tokens: config > request > undefined
+      ...(configSamplingParams?.max_tokens !== undefined
+        ? { max_tokens: configSamplingParams.max_tokens }
+        : request.config?.maxOutputTokens !== undefined
+          ? { max_tokens: request.config.maxOutputTokens }
+          : {}),
+
+      // Top-p: config > request > default
+      top_p:
+        configSamplingParams?.top_p !== undefined
+          ? configSamplingParams.top_p
+          : request.config?.topP !== undefined
+            ? request.config.topP
+            : 1.0,
+
+      // Top-k: config only (not available in request)
+      ...(configSamplingParams?.top_k !== undefined
+        ? { top_k: configSamplingParams.top_k }
+        : {}),
+
+      // Repetition penalty: config only
+      ...(configSamplingParams?.repetition_penalty !== undefined
+        ? { repetition_penalty: configSamplingParams.repetition_penalty }
+        : {}),
+
+      // Presence penalty: config only
+      ...(configSamplingParams?.presence_penalty !== undefined
+        ? { presence_penalty: configSamplingParams.presence_penalty }
+        : {}),
+
+      // Frequency penalty: config only
+      ...(configSamplingParams?.frequency_penalty !== undefined
+        ? { frequency_penalty: configSamplingParams.frequency_penalty }
+        : {}),
+    };
+
+    return params;
+  }
+
+  private mapFinishReason(openaiReason: string | null): FinishReason {
+    if (!openaiReason) return FinishReason.FINISH_REASON_UNSPECIFIED;
+    const mapping: Record<string, FinishReason> = {
+      stop: FinishReason.STOP,
+      length: FinishReason.MAX_TOKENS,
+      content_filter: FinishReason.SAFETY,
+      function_call: FinishReason.STOP,
+      tool_calls: FinishReason.STOP,
+    };
+    return mapping[openaiReason] || FinishReason.FINISH_REASON_UNSPECIFIED;
+  }
+
+  /**
+   * Convert Gemini response format to OpenAI chat completion format for logging
+   */
+  private convertGeminiResponseToOpenAI(
+    response: GenerateContentResponse,
+  ): OpenAIResponseFormat {
+    const candidate = response.candidates?.[0];
+    const content = candidate?.content;
+
+    let messageContent: string | null = null;
+    const toolCalls: OpenAIToolCall[] = [];
+
+    if (content?.parts) {
+      const textParts: string[] = [];
+
+      for (const part of content.parts) {
+        if ('text' in part && part.text) {
+          textParts.push(part.text);
+        } else if ('functionCall' in part && part.functionCall) {
+          toolCalls.push({
+            id: part.functionCall.id || `call_${toolCalls.length}`,
+            type: 'function' as const,
+            function: {
+              name: part.functionCall.name || '',
+              arguments: JSON.stringify(part.functionCall.args || {}),
+            },
+          });
+        }
+      }
+
+      messageContent = textParts.join('').trimEnd();
+    }
+
+    const choice: OpenAIChoice = {
+      index: 0,
+      message: {
+        role: 'assistant',
+        content: messageContent,
+      },
+      finish_reason: this.mapGeminiFinishReasonToOpenAI(
+        candidate?.finishReason,
+      ),
+    };
+
+    if (toolCalls.length > 0) {
+      choice.message.tool_calls = toolCalls;
+    }
+
+    const openaiResponse: OpenAIResponseFormat = {
+      id: response.responseId || `chatcmpl-${Date.now()}`,
+      object: 'chat.completion',
+      created: response.createTime
+        ? Number(response.createTime)
+        : Math.floor(Date.now() / 1000),
+      model: this.model,
+      choices: [choice],
+    };
+
+    // Add usage metadata if available
+    if (response.usageMetadata) {
+      openaiResponse.usage = {
+        prompt_tokens: response.usageMetadata.promptTokenCount || 0,
+        completion_tokens: response.usageMetadata.candidatesTokenCount || 0,
+        total_tokens: response.usageMetadata.totalTokenCount || 0,
+      };
+
+      if (response.usageMetadata.cachedContentTokenCount) {
+        openaiResponse.usage.prompt_tokens_details = {
+          cached_tokens: response.usageMetadata.cachedContentTokenCount,
+        };
+      }
+    }
+
+    return openaiResponse;
+  }
+
+  /**
+   * Map Gemini finish reasons to OpenAI finish reasons
+   */
+  private mapGeminiFinishReasonToOpenAI(geminiReason?: unknown): string {
+    if (!geminiReason) return 'stop';
+
+    switch (geminiReason) {
+      case 'STOP':
+      case 1: // FinishReason.STOP
+        return 'stop';
+      case 'MAX_TOKENS':
+      case 2: // FinishReason.MAX_TOKENS
+        return 'length';
+      case 'SAFETY':
+      case 3: // FinishReason.SAFETY
+        return 'content_filter';
+      case 'RECITATION':
+      case 4: // FinishReason.RECITATION
+        return 'content_filter';
+      case 'OTHER':
+      case 5: // FinishReason.OTHER
+        return 'stop';
+      default:
+        return 'stop';
+    }
+  }
+}

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

@@ -0,0 +1,365 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { getCoreSystemPrompt } from './prompts.js';
+import { isGitRepository } from '../utils/gitUtils.js';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { GEMINI_CONFIG_DIR } from '../tools/memoryTool.js';
+
+// Mock tool names if they are dynamically generated or complex
+vi.mock('../tools/ls', () => ({ LSTool: { Name: 'list_directory' } }));
+vi.mock('../tools/edit', () => ({ EditTool: { Name: 'replace' } }));
+vi.mock('../tools/glob', () => ({ GlobTool: { Name: 'glob' } }));
+vi.mock('../tools/grep', () => ({ GrepTool: { Name: 'search_file_content' } }));
+vi.mock('../tools/read-file', () => ({ ReadFileTool: { Name: 'read_file' } }));
+vi.mock('../tools/read-many-files', () => ({
+  ReadManyFilesTool: { Name: 'read_many_files' },
+}));
+vi.mock('../tools/shell', () => ({
+  ShellTool: { Name: 'run_shell_command' },
+}));
+vi.mock('../tools/write-file', () => ({
+  WriteFileTool: { Name: 'write_file' },
+}));
+vi.mock('../utils/gitUtils', () => ({
+  isGitRepository: vi.fn(),
+}));
+vi.mock('node:fs');
+
+describe('Core System Prompt (prompts.ts)', () => {
+  beforeEach(() => {
+    vi.resetAllMocks();
+    vi.stubEnv('GEMINI_SYSTEM_MD', undefined);
+    vi.stubEnv('GEMINI_WRITE_SYSTEM_MD', undefined);
+  });
+
+  it('should return the base prompt when no userMemory is provided', () => {
+    vi.stubEnv('SANDBOX', undefined);
+    const prompt = getCoreSystemPrompt();
+    expect(prompt).not.toContain('---\n\n'); // Separator should not be present
+    expect(prompt).toContain('You are Qwen Code, an interactive CLI agent'); // Check for core content
+    expect(prompt).toMatchSnapshot(); // Use snapshot for base prompt structure
+  });
+
+  it('should return the base prompt when userMemory is empty string', () => {
+    vi.stubEnv('SANDBOX', undefined);
+    const prompt = getCoreSystemPrompt('');
+    expect(prompt).not.toContain('---\n\n');
+    expect(prompt).toContain('You are Qwen Code, an interactive CLI agent');
+    expect(prompt).toMatchSnapshot();
+  });
+
+  it('should return the base prompt when userMemory is whitespace only', () => {
+    vi.stubEnv('SANDBOX', undefined);
+    const prompt = getCoreSystemPrompt('   \n  \t ');
+    expect(prompt).not.toContain('---\n\n');
+    expect(prompt).toContain('You are Qwen Code, an interactive CLI agent');
+    expect(prompt).toMatchSnapshot();
+  });
+
+  it('should append userMemory with separator when provided', () => {
+    vi.stubEnv('SANDBOX', undefined);
+    const memory = 'This is custom user memory.\nBe extra polite.';
+    const expectedSuffix = `\n\n---\n\n${memory}`;
+    const prompt = getCoreSystemPrompt(memory);
+
+    expect(prompt.endsWith(expectedSuffix)).toBe(true);
+    expect(prompt).toContain('You are Qwen Code, an interactive CLI agent'); // Ensure base prompt follows
+    expect(prompt).toMatchSnapshot(); // Snapshot the combined prompt
+  });
+
+  it('should include sandbox-specific instructions when SANDBOX env var is set', () => {
+    vi.stubEnv('SANDBOX', 'true'); // Generic sandbox value
+    const prompt = getCoreSystemPrompt();
+    expect(prompt).toContain('# Sandbox');
+    expect(prompt).not.toContain('# macOS Seatbelt');
+    expect(prompt).not.toContain('# Outside of Sandbox');
+    expect(prompt).toMatchSnapshot();
+  });
+
+  it('should include seatbelt-specific instructions when SANDBOX env var is "sandbox-exec"', () => {
+    vi.stubEnv('SANDBOX', 'sandbox-exec');
+    const prompt = getCoreSystemPrompt();
+    expect(prompt).toContain('# macOS Seatbelt');
+    expect(prompt).not.toContain('# Sandbox');
+    expect(prompt).not.toContain('# Outside of Sandbox');
+    expect(prompt).toMatchSnapshot();
+  });
+
+  it('should include non-sandbox instructions when SANDBOX env var is not set', () => {
+    vi.stubEnv('SANDBOX', undefined); // Ensure it's not set
+    const prompt = getCoreSystemPrompt();
+    expect(prompt).toContain('# Outside of Sandbox');
+    expect(prompt).not.toContain('# Sandbox');
+    expect(prompt).not.toContain('# macOS Seatbelt');
+    expect(prompt).toMatchSnapshot();
+  });
+
+  it('should include git instructions when in a git repo', () => {
+    vi.stubEnv('SANDBOX', undefined);
+    vi.mocked(isGitRepository).mockReturnValue(true);
+    const prompt = getCoreSystemPrompt();
+    expect(prompt).toContain('# Git Repository');
+    expect(prompt).toMatchSnapshot();
+  });
+
+  it('should not include git instructions when not in a git repo', () => {
+    vi.stubEnv('SANDBOX', undefined);
+    vi.mocked(isGitRepository).mockReturnValue(false);
+    const prompt = getCoreSystemPrompt();
+    expect(prompt).not.toContain('# Git Repository');
+    expect(prompt).toMatchSnapshot();
+  });
+
+  describe('GEMINI_SYSTEM_MD environment variable', () => {
+    it('should use default prompt when GEMINI_SYSTEM_MD is "false"', () => {
+      vi.stubEnv('GEMINI_SYSTEM_MD', 'false');
+      const prompt = getCoreSystemPrompt();
+      expect(fs.readFileSync).not.toHaveBeenCalled();
+      expect(prompt).not.toContain('custom system prompt');
+    });
+
+    it('should use default prompt when GEMINI_SYSTEM_MD is "0"', () => {
+      vi.stubEnv('GEMINI_SYSTEM_MD', '0');
+      const prompt = getCoreSystemPrompt();
+      expect(fs.readFileSync).not.toHaveBeenCalled();
+      expect(prompt).not.toContain('custom system prompt');
+    });
+
+    it('should throw error if GEMINI_SYSTEM_MD points to a non-existent file', () => {
+      const customPath = '/non/existent/path/system.md';
+      vi.stubEnv('GEMINI_SYSTEM_MD', customPath);
+      vi.mocked(fs.existsSync).mockReturnValue(false);
+      expect(() => getCoreSystemPrompt()).toThrow(
+        `missing system prompt file '${path.resolve(customPath)}'`,
+      );
+    });
+
+    it('should read from default path when GEMINI_SYSTEM_MD is "true"', () => {
+      const defaultPath = path.resolve(
+        path.join(GEMINI_CONFIG_DIR, 'system.md'),
+      );
+      vi.stubEnv('GEMINI_SYSTEM_MD', 'true');
+      vi.mocked(fs.existsSync).mockReturnValue(true);
+      vi.mocked(fs.readFileSync).mockReturnValue('custom system prompt');
+
+      const prompt = getCoreSystemPrompt();
+      expect(fs.readFileSync).toHaveBeenCalledWith(defaultPath, 'utf8');
+      expect(prompt).toBe('custom system prompt');
+    });
+
+    it('should read from default path when GEMINI_SYSTEM_MD is "1"', () => {
+      const defaultPath = path.resolve(
+        path.join(GEMINI_CONFIG_DIR, 'system.md'),
+      );
+      vi.stubEnv('GEMINI_SYSTEM_MD', '1');
+      vi.mocked(fs.existsSync).mockReturnValue(true);
+      vi.mocked(fs.readFileSync).mockReturnValue('custom system prompt');
+
+      const prompt = getCoreSystemPrompt();
+      expect(fs.readFileSync).toHaveBeenCalledWith(defaultPath, 'utf8');
+      expect(prompt).toBe('custom system prompt');
+    });
+
+    it('should read from custom path when GEMINI_SYSTEM_MD provides one, preserving case', () => {
+      const customPath = path.resolve('/custom/path/SyStEm.Md');
+      vi.stubEnv('GEMINI_SYSTEM_MD', customPath);
+      vi.mocked(fs.existsSync).mockReturnValue(true);
+      vi.mocked(fs.readFileSync).mockReturnValue('custom system prompt');
+
+      const prompt = getCoreSystemPrompt();
+      expect(fs.readFileSync).toHaveBeenCalledWith(customPath, 'utf8');
+      expect(prompt).toBe('custom system prompt');
+    });
+
+    it('should expand tilde in custom path when GEMINI_SYSTEM_MD is set', () => {
+      const homeDir = '/Users/test';
+      vi.spyOn(os, 'homedir').mockReturnValue(homeDir);
+      const customPath = '~/custom/system.md';
+      const expectedPath = path.join(homeDir, 'custom/system.md');
+      vi.stubEnv('GEMINI_SYSTEM_MD', customPath);
+      vi.mocked(fs.existsSync).mockReturnValue(true);
+      vi.mocked(fs.readFileSync).mockReturnValue('custom system prompt');
+
+      const prompt = getCoreSystemPrompt();
+      expect(fs.readFileSync).toHaveBeenCalledWith(
+        path.resolve(expectedPath),
+        'utf8',
+      );
+      expect(prompt).toBe('custom system prompt');
+    });
+  });
+
+  describe('GEMINI_WRITE_SYSTEM_MD environment variable', () => {
+    it('should not write to file when GEMINI_WRITE_SYSTEM_MD is "false"', () => {
+      vi.stubEnv('GEMINI_WRITE_SYSTEM_MD', 'false');
+      getCoreSystemPrompt();
+      expect(fs.writeFileSync).not.toHaveBeenCalled();
+    });
+
+    it('should not write to file when GEMINI_WRITE_SYSTEM_MD is "0"', () => {
+      vi.stubEnv('GEMINI_WRITE_SYSTEM_MD', '0');
+      getCoreSystemPrompt();
+      expect(fs.writeFileSync).not.toHaveBeenCalled();
+    });
+
+    it('should write to default path when GEMINI_WRITE_SYSTEM_MD is "true"', () => {
+      const defaultPath = path.resolve(
+        path.join(GEMINI_CONFIG_DIR, 'system.md'),
+      );
+      vi.stubEnv('GEMINI_WRITE_SYSTEM_MD', 'true');
+      getCoreSystemPrompt();
+      expect(fs.writeFileSync).toHaveBeenCalledWith(
+        defaultPath,
+        expect.any(String),
+      );
+    });
+
+    it('should write to default path when GEMINI_WRITE_SYSTEM_MD is "1"', () => {
+      const defaultPath = path.resolve(
+        path.join(GEMINI_CONFIG_DIR, 'system.md'),
+      );
+      vi.stubEnv('GEMINI_WRITE_SYSTEM_MD', '1');
+      getCoreSystemPrompt();
+      expect(fs.writeFileSync).toHaveBeenCalledWith(
+        defaultPath,
+        expect.any(String),
+      );
+    });
+
+    it('should write to custom path when GEMINI_WRITE_SYSTEM_MD provides one', () => {
+      const customPath = path.resolve('/custom/path/system.md');
+      vi.stubEnv('GEMINI_WRITE_SYSTEM_MD', customPath);
+      getCoreSystemPrompt();
+      expect(fs.writeFileSync).toHaveBeenCalledWith(
+        customPath,
+        expect.any(String),
+      );
+    });
+
+    it('should expand tilde in custom path when GEMINI_WRITE_SYSTEM_MD is set', () => {
+      const homeDir = '/Users/test';
+      vi.spyOn(os, 'homedir').mockReturnValue(homeDir);
+      const customPath = '~/custom/system.md';
+      const expectedPath = path.join(homeDir, 'custom/system.md');
+      vi.stubEnv('GEMINI_WRITE_SYSTEM_MD', customPath);
+      getCoreSystemPrompt();
+      expect(fs.writeFileSync).toHaveBeenCalledWith(
+        path.resolve(expectedPath),
+        expect.any(String),
+      );
+    });
+
+    it('should expand tilde in custom path when GEMINI_WRITE_SYSTEM_MD is just ~', () => {
+      const homeDir = '/Users/test';
+      vi.spyOn(os, 'homedir').mockReturnValue(homeDir);
+      const customPath = '~';
+      const expectedPath = homeDir;
+      vi.stubEnv('GEMINI_WRITE_SYSTEM_MD', customPath);
+      getCoreSystemPrompt();
+      expect(fs.writeFileSync).toHaveBeenCalledWith(
+        path.resolve(expectedPath),
+        expect.any(String),
+      );
+    });
+  });
+});
+
+describe('URL matching with trailing slash compatibility', () => {
+  it('should match URLs with and without trailing slash', () => {
+    const config = {
+      systemPromptMappings: [
+        {
+          baseUrls: ['https://api.example.com'],
+          modelNames: ['gpt-4'],
+          template: 'Custom template for example.com',
+        },
+        {
+          baseUrls: ['https://api.openai.com/'],
+          modelNames: ['gpt-3.5-turbo'],
+          template: 'Custom template for openai.com',
+        },
+      ],
+    };
+
+    // Simulate environment variables
+    const originalEnv = process.env;
+
+    // Test case 1: No trailing slash in config, actual URL has trailing slash
+    process.env = {
+      ...originalEnv,
+      OPENAI_BASE_URL: 'https://api.example.com/',
+      OPENAI_MODEL: 'gpt-4',
+    };
+
+    const result1 = getCoreSystemPrompt(undefined, config);
+    expect(result1).toContain('Custom template for example.com');
+
+    // Test case 2: Config has trailing slash, actual URL has no trailing slash
+    process.env = {
+      ...originalEnv,
+      OPENAI_BASE_URL: 'https://api.openai.com',
+      OPENAI_MODEL: 'gpt-3.5-turbo',
+    };
+
+    const result2 = getCoreSystemPrompt(undefined, config);
+    expect(result2).toContain('Custom template for openai.com');
+
+    // Test case 3: No trailing slash in config, actual URL has no trailing slash
+    process.env = {
+      ...originalEnv,
+      OPENAI_BASE_URL: 'https://api.example.com',
+      OPENAI_MODEL: 'gpt-4',
+    };
+
+    const result3 = getCoreSystemPrompt(undefined, config);
+    expect(result3).toContain('Custom template for example.com');
+
+    // Test case 4: Config has trailing slash, actual URL has trailing slash
+    process.env = {
+      ...originalEnv,
+      OPENAI_BASE_URL: 'https://api.openai.com/',
+      OPENAI_MODEL: 'gpt-3.5-turbo',
+    };
+
+    const result4 = getCoreSystemPrompt(undefined, config);
+    expect(result4).toContain('Custom template for openai.com');
+
+    // Restore original environment variables
+    process.env = originalEnv;
+  });
+
+  it('should not match when URLs are different', () => {
+    const config = {
+      systemPromptMappings: [
+        {
+          baseUrls: ['https://api.example.com'],
+          modelNames: ['gpt-4'],
+          template: 'Custom template for example.com',
+        },
+      ],
+    };
+
+    const originalEnv = process.env;
+
+    // Test case: URLs do not match
+    process.env = {
+      ...originalEnv,
+      OPENAI_BASE_URL: 'https://api.different.com',
+      OPENAI_MODEL: 'gpt-4',
+    };
+
+    const result = getCoreSystemPrompt(undefined, config);
+    // Should return default template, not contain custom template
+    expect(result).not.toContain('Custom template for example.com');
+
+    // Restore original environment variables
+    process.env = originalEnv;
+  });
+});

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

@@ -0,0 +1,542 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import path from 'node:path';
+import fs from 'node:fs';
+import os from 'node:os';
+import { EditTool } from '../tools/edit.js';
+import { GlobTool } from '../tools/glob.js';
+import { GrepTool } from '../tools/grep.js';
+import { ReadFileTool } from '../tools/read-file.js';
+import { ReadManyFilesTool } from '../tools/read-many-files.js';
+import { ShellTool } from '../tools/shell.js';
+import { WriteFileTool } from '../tools/write-file.js';
+import process from 'node:process';
+import { isGitRepository } from '../utils/gitUtils.js';
+import { MemoryTool, GEMINI_CONFIG_DIR } from '../tools/memoryTool.js';
+import { TodoWriteTool } from '../tools/todoWrite.js';
+
+export interface ModelTemplateMapping {
+  baseUrls?: string[];
+  modelNames?: string[];
+  template?: string;
+}
+
+export interface SystemPromptConfig {
+  systemPromptMappings?: ModelTemplateMapping[];
+}
+
+/**
+ * Normalizes a URL by removing trailing slash for consistent comparison
+ */
+function normalizeUrl(url: string): string {
+  return url.endsWith('/') ? url.slice(0, -1) : url;
+}
+
+/**
+ * Checks if a URL matches any URL in the array, ignoring trailing slashes
+ */
+function urlMatches(urlArray: string[], targetUrl: string): boolean {
+  const normalizedTarget = normalizeUrl(targetUrl);
+  return urlArray.some((url) => normalizeUrl(url) === normalizedTarget);
+}
+
+export function getCoreSystemPrompt(
+  userMemory?: string,
+  config?: SystemPromptConfig,
+): string {
+  // if GEMINI_SYSTEM_MD is set (and not 0|false), override system prompt from file
+  // default path is .gemini/system.md but can be modified via custom path in GEMINI_SYSTEM_MD
+  let systemMdEnabled = false;
+  let systemMdPath = path.resolve(path.join(GEMINI_CONFIG_DIR, 'system.md'));
+  const systemMdVar = process.env['GEMINI_SYSTEM_MD'];
+  if (systemMdVar) {
+    const systemMdVarLower = systemMdVar.toLowerCase();
+    if (!['0', 'false'].includes(systemMdVarLower)) {
+      systemMdEnabled = true; // enable system prompt override
+      if (!['1', 'true'].includes(systemMdVarLower)) {
+        let customPath = systemMdVar;
+        if (customPath.startsWith('~/')) {
+          customPath = path.join(os.homedir(), customPath.slice(2));
+        } else if (customPath === '~') {
+          customPath = os.homedir();
+        }
+        systemMdPath = path.resolve(customPath); // use custom path from GEMINI_SYSTEM_MD
+      }
+      // require file to exist when override is enabled
+      if (!fs.existsSync(systemMdPath)) {
+        throw new Error(`missing system prompt file '${systemMdPath}'`);
+      }
+    }
+  }
+
+  // Check for system prompt mappings from global config
+  if (config?.systemPromptMappings) {
+    const currentModel = process.env['OPENAI_MODEL'] || '';
+    const currentBaseUrl = process.env['OPENAI_BASE_URL'] || '';
+
+    const matchedMapping = config.systemPromptMappings.find((mapping) => {
+      const { baseUrls, modelNames } = mapping;
+      // Check if baseUrl matches (when specified)
+      if (
+        baseUrls &&
+        modelNames &&
+        urlMatches(baseUrls, currentBaseUrl) &&
+        modelNames.includes(currentModel)
+      ) {
+        return true;
+      }
+
+      if (baseUrls && urlMatches(baseUrls, currentBaseUrl) && !modelNames) {
+        return true;
+      }
+      if (modelNames && modelNames.includes(currentModel) && !baseUrls) {
+        return true;
+      }
+
+      return false;
+    });
+
+    if (matchedMapping?.template) {
+      const isGitRepo = isGitRepository(process.cwd());
+
+      // Replace placeholders in template
+      let template = matchedMapping.template;
+      template = template.replace(
+        '{RUNTIME_VARS_IS_GIT_REPO}',
+        String(isGitRepo),
+      );
+      template = template.replace(
+        '{RUNTIME_VARS_SANDBOX}',
+        process.env['SANDBOX'] || '',
+      );
+
+      return template;
+    }
+  }
+
+  const basePrompt = systemMdEnabled
+    ? fs.readFileSync(systemMdPath, 'utf8')
+    : `
+You are Qwen Code, an interactive CLI agent developed by Alibaba Group, specializing in software engineering tasks. Your primary goal is to help users safely and efficiently, adhering strictly to the following instructions and utilizing your available tools.
+
+# Core Mandates
+
+- **Conventions:** Rigorously adhere to existing project conventions when reading or modifying code. Analyze surrounding code, tests, and configuration first.
+- **Libraries/Frameworks:** NEVER assume a library/framework is available or appropriate. Verify its established usage within the project (check imports, configuration files like 'package.json', 'Cargo.toml', 'requirements.txt', 'build.gradle', etc., or observe neighboring files) before employing it.
+- **Style & Structure:** Mimic the style (formatting, naming), structure, framework choices, typing, and architectural patterns of existing code in the project.
+- **Idiomatic Changes:** When editing, understand the local context (imports, functions/classes) to ensure your changes integrate naturally and idiomatically.
+- **Comments:** Add code comments sparingly. Focus on *why* something is done, especially for complex logic, rather than *what* is done. Only add high-value comments if necessary for clarity or if requested by the user. Do not edit comments that are separate from the code you are changing. *NEVER* talk to the user or describe your changes through comments.
+- **Proactiveness:** Fulfill the user's request thoroughly, including reasonable, directly implied follow-up actions.
+- **Confirm Ambiguity/Expansion:** Do not take significant actions beyond the clear scope of the request without confirming with the user. If asked *how* to do something, explain first, don't just do it.
+- **Explaining Changes:** After completing a code modification or file operation *do not* provide summaries unless asked.
+- **Path Construction:** Before using any file system tool (e.g., ${ReadFileTool.Name}' or '${WriteFileTool.Name}'), you must construct the full absolute path for the file_path argument. Always combine the absolute path of the project's root directory with the file's path relative to the root. For example, if the project root is /path/to/project/ and the file is foo/bar/baz.txt, the final path you must use is /path/to/project/foo/bar/baz.txt. If the user provides a relative path, you must resolve it against the root directory to create an absolute path.
+- **Do Not revert changes:** Do not revert changes to the codebase unless asked to do so by the user. Only revert changes made by you if they have resulted in an error or if the user has explicitly asked you to revert the changes.
+
+# Task Management
+You have access to the ${TodoWriteTool.Name} tool to help you manage and plan tasks. Use these tools VERY frequently to ensure that you are tracking your tasks and giving the user visibility into your progress.
+These tools are also EXTREMELY helpful for planning tasks, and for breaking down larger complex tasks into smaller steps. If you do not use this tool when planning, you may forget to do important tasks - and that is unacceptable.
+
+It is critical that you mark todos as completed as soon as you are done with a task. Do not batch up multiple tasks before marking them as completed.
+
+Examples:
+
+<example>
+user: Run the build and fix any type errors
+assistant: I'm going to use the ${TodoWriteTool.Name} tool to write the following items to the todo list: 
+- Run the build
+- Fix any type errors
+
+I'm now going to run the build using Bash.
+
+Looks like I found 10 type errors. I'm going to use the ${TodoWriteTool.Name} tool to write 10 items to the todo list.
+
+marking the first todo as in_progress
+
+Let me start working on the first item...
+
+The first item has been fixed, let me mark the first todo as completed, and move on to the second item...
+..
+..
+</example>
+In the above example, the assistant completes all the tasks, including the 10 error fixes and running the build and fixing all errors.
+
+<example>
+user: Help me write a new feature that allows users to track their usage metrics and export them to various formats
+
+A: I'll help you implement a usage metrics tracking and export feature. Let me first use the ${TodoWriteTool.Name} tool to plan this task.
+Adding the following todos to the todo list:
+1. Research existing metrics tracking in the codebase
+2. Design the metrics collection system
+3. Implement core metrics tracking functionality
+4. Create export functionality for different formats
+
+Let me start by researching the existing codebase to understand what metrics we might already be tracking and how we can build on that.
+
+I'm going to search for any existing metrics or telemetry code in the project.
+
+I've found some existing telemetry code. Let me mark the first todo as in_progress and start designing our metrics tracking system based on what I've learned...
+
+[Assistant continues implementing the feature step by step, marking todos as in_progress and completed as they go]
+</example>
+
+
+# Primary Workflows
+
+## Software Engineering Tasks
+When requested to perform tasks like fixing bugs, adding features, refactoring, or explaining code, follow this iterative approach:
+- **Plan:** After understanding the user's request, create an initial plan based on your existing knowledge and any immediately obvious context. Use the '${TodoWriteTool.Name}' tool to capture this rough plan for complex or multi-step work. Don't wait for complete understanding - start with what you know.
+- **Implement:** Begin implementing the plan while gathering additional context as needed. Use '${GrepTool.Name}', '${GlobTool.Name}', '${ReadFileTool.Name}', and '${ReadManyFilesTool.Name}' tools strategically when you encounter specific unknowns during implementation. Use the available tools (e.g., '${EditTool.Name}', '${WriteFileTool.Name}' '${ShellTool.Name}' ...) to act on the plan, strictly adhering to the project's established conventions (detailed under 'Core Mandates').
+- **Adapt:** As you discover new information or encounter obstacles, update your plan and todos accordingly. Mark todos as in_progress when starting and completed when finishing each task. Add new todos if the scope expands. Refine your approach based on what you learn.
+- **Verify (Tests):** If applicable and feasible, verify the changes using the project's testing procedures. Identify the correct test commands and frameworks by examining 'README' files, build/package configuration (e.g., 'package.json'), or existing test execution patterns. NEVER assume standard test commands.
+- **Verify (Standards):** VERY IMPORTANT: After making code changes, execute the project-specific build, linting and type-checking commands (e.g., 'tsc', 'npm run lint', 'ruff check .') that you have identified for this project (or obtained from the user). This ensures code quality and adherence to standards. If unsure about these commands, you can ask the user if they'd like you to run them and if so how to.
+
+**Key Principle:** Start with a reasonable plan based on available information, then adapt as you learn. Users prefer seeing progress quickly rather than waiting for perfect understanding.
+
+- Tool results and user messages may include <system-reminder> tags. <system-reminder> tags contain useful information and reminders. They are NOT part of the user's provided input or the tool result.
+
+IMPORTANT: Always use the ${TodoWriteTool.Name} tool to plan and track tasks throughout the conversation.
+
+## New Applications
+
+**Goal:** Autonomously implement and deliver a visually appealing, substantially complete, and functional prototype. Utilize all tools at your disposal to implement the application. Some tools you may especially find useful are '${WriteFileTool.Name}', '${EditTool.Name}' and '${ShellTool.Name}'.
+
+1. **Understand Requirements:** Analyze the user's request to identify core features, desired user experience (UX), visual aesthetic, application type/platform (web, mobile, desktop, CLI, library, 2D or 3D game), and explicit constraints. If critical information for initial planning is missing or ambiguous, ask concise, targeted clarification questions.
+2. **Propose Plan:** Formulate an internal development plan. Present a clear, concise, high-level summary to the user. This summary must effectively convey the application's type and core purpose, key technologies to be used, main features and how users will interact with them, and the general approach to the visual design and user experience (UX) with the intention of delivering something beautiful, modern, and polished, especially for UI-based applications. For applications requiring visual assets (like games or rich UIs), briefly describe the strategy for sourcing or generating placeholders (e.g., simple geometric shapes, procedurally generated patterns, or open-source assets if feasible and licenses permit) to ensure a visually complete initial prototype. Ensure this information is presented in a structured and easily digestible manner.
+  - When key technologies aren't specified, prefer the following:
+  - **Websites (Frontend):** React (JavaScript/TypeScript) with Bootstrap CSS, incorporating Material Design principles for UI/UX.
+  - **Back-End APIs:** Node.js with Express.js (JavaScript/TypeScript) or Python with FastAPI.
+  - **Full-stack:** Next.js (React/Node.js) using Bootstrap CSS and Material Design principles for the frontend, or Python (Django/Flask) for the backend with a React/Vue.js frontend styled with Bootstrap CSS and Material Design principles.
+  - **CLIs:** Python or Go.
+  - **Mobile App:** Compose Multiplatform (Kotlin Multiplatform) or Flutter (Dart) using Material Design libraries and principles, when sharing code between Android and iOS. Jetpack Compose (Kotlin JVM) with Material Design principles or SwiftUI (Swift) for native apps targeted at either Android or iOS, respectively.
+  - **3d Games:** HTML/CSS/JavaScript with Three.js.
+  - **2d Games:** HTML/CSS/JavaScript.
+3. **User Approval:** Obtain user approval for the proposed plan.
+4. **Implementation:** Use the '${TodoWriteTool.Name}' tool to convert the approved plan into a structured todo list with specific, actionable tasks, then autonomously implement each task utilizing all available tools. When starting ensure you scaffold the application using '${ShellTool.Name}' for commands like 'npm init', 'npx create-react-app'. Aim for full scope completion. Proactively create or source necessary placeholder assets (e.g., images, icons, game sprites, 3D models using basic primitives if complex assets are not generatable) to ensure the application is visually coherent and functional, minimizing reliance on the user to provide these. If the model can generate simple assets (e.g., a uniformly colored square sprite, a simple 3D cube), it should do so. Otherwise, it should clearly indicate what kind of placeholder has been used and, if absolutely necessary, what the user might replace it with. Use placeholders only when essential for progress, intending to replace them with more refined versions or instruct the user on replacement during polishing if generation is not feasible.
+5. **Verify:** Review work against the original request, the approved plan. Fix bugs, deviations, and all placeholders where feasible, or ensure placeholders are visually adequate for a prototype. Ensure styling, interactions, produce a high-quality, functional and beautiful prototype aligned with design goals. Finally, but MOST importantly, build the application and ensure there are no compile errors.
+6. **Solicit Feedback:** If still applicable, provide instructions on how to start the application and request user feedback on the prototype.
+
+# Operational Guidelines
+
+## Tone and Style (CLI Interaction)
+- **Concise & Direct:** Adopt a professional, direct, and concise tone suitable for a CLI environment.
+- **Minimal Output:** Aim for fewer than 3 lines of text output (excluding tool use/code generation) per response whenever practical. Focus strictly on the user's query.
+- **Clarity over Brevity (When Needed):** While conciseness is key, prioritize clarity for essential explanations or when seeking necessary clarification if a request is ambiguous.
+- **No Chitchat:** Avoid conversational filler, preambles ("Okay, I will now..."), or postambles ("I have finished the changes..."). Get straight to the action or answer.
+- **Formatting:** Use GitHub-flavored Markdown. Responses will be rendered in monospace.
+- **Tools vs. Text:** Use tools for actions, text output *only* for communication. Do not add explanatory comments within tool calls or code blocks unless specifically part of the required code/command itself.
+- **Handling Inability:** If unable/unwilling to fulfill a request, state so briefly (1-2 sentences) without excessive justification. Offer alternatives if appropriate.
+
+## Security and Safety Rules
+- **Explain Critical Commands:** Before executing commands with '${ShellTool.Name}' that modify the file system, codebase, or system state, you *must* provide a brief explanation of the command's purpose and potential impact. Prioritize user understanding and safety. You should not ask permission to use the tool; the user will be presented with a confirmation dialogue upon use (you do not need to tell them this).
+- **Security First:** Always apply security best practices. Never introduce code that exposes, logs, or commits secrets, API keys, or other sensitive information.
+
+## Tool Usage
+- **File Paths:** Always use absolute paths when referring to files with tools like '${ReadFileTool.Name}' or '${WriteFileTool.Name}'. Relative paths are not supported. You must provide an absolute path.
+- **Parallelism:** Execute multiple independent tool calls in parallel when feasible (i.e. searching the codebase).
+- **Command Execution:** Use the '${ShellTool.Name}' tool for running shell commands, remembering the safety rule to explain modifying commands first.
+- **Background Processes:** Use background processes (via \`&\`) for commands that are unlikely to stop on their own, e.g. \`node server.js &\`. If unsure, ask the user.
+- **Interactive Commands:** Try to avoid shell commands that are likely to require user interaction (e.g. \`git rebase -i\`). Use non-interactive versions of commands (e.g. \`npm init -y\` instead of \`npm init\`) when available, and otherwise remind the user that interactive shell commands are not supported and may cause hangs until canceled by the user.
+- **Task Management:** Use the '${TodoWriteTool.Name}' tool proactively for complex, multi-step tasks to track progress and provide visibility to users. This tool helps organize work systematically and ensures no requirements are missed.
+- **Remembering Facts:** Use the '${MemoryTool.Name}' tool to remember specific, *user-related* facts or preferences when the user explicitly asks, or when they state a clear, concise piece of information that would help personalize or streamline *your future interactions with them* (e.g., preferred coding style, common project paths they use, personal tool aliases). This tool is for user-specific information that should persist across sessions. Do *not* use it for general project context or information. If unsure whether to save something, you can ask the user, "Should I remember that for you?"
+- **Respect User Confirmations:** Most tool calls (also denoted as 'function calls') will first require confirmation from the user, where they will either approve or cancel the function call. If a user cancels a function call, respect their choice and do _not_ try to make the function call again. It is okay to request the tool call again _only_ if the user requests that same tool call on a subsequent prompt. When a user cancels a function call, assume best intentions from the user and consider inquiring if they prefer any alternative paths forward.
+
+## Interaction Details
+- **Help Command:** The user can use '/help' to display help information.
+- **Feedback:** To report a bug or provide feedback, please use the /bug command.
+
+${(function () {
+  // Determine sandbox status based on environment variables
+  const isSandboxExec = process.env['SANDBOX'] === 'sandbox-exec';
+  const isGenericSandbox = !!process.env['SANDBOX']; // Check if SANDBOX is set to any non-empty value
+
+  if (isSandboxExec) {
+    return `
+# macOS Seatbelt
+You are running under macos seatbelt with limited access to files outside the project directory or system temp directory, and with limited access to host system resources such as ports. If you encounter failures that could be due to MacOS Seatbelt (e.g. if a command fails with 'Operation not permitted' or similar error), as you report the error to the user, also explain why you think it could be due to MacOS Seatbelt, and how the user may need to adjust their Seatbelt profile.
+`;
+  } else if (isGenericSandbox) {
+    return `
+# Sandbox
+You are running in a sandbox container with limited access to files outside the project directory or system temp directory, and with limited access to host system resources such as ports. If you encounter failures that could be due to sandboxing (e.g. if a command fails with 'Operation not permitted' or similar error), when you report the error to the user, also explain why you think it could be due to sandboxing, and how the user may need to adjust their sandbox configuration.
+`;
+  } else {
+    return `
+# Outside of Sandbox
+You are running outside of a sandbox container, directly on the user's system. For critical commands that are particularly likely to modify the user's system outside of the project directory or system temp directory, as you explain the command to the user (per the Explain Critical Commands rule above), also remind the user to consider enabling sandboxing.
+`;
+  }
+})()}
+
+${(function () {
+  if (isGitRepository(process.cwd())) {
+    return `
+# Git Repository
+- The current working (project) directory is being managed by a git repository.
+- When asked to commit changes or prepare a commit, always start by gathering information using shell commands:
+  - \`git status\` to ensure that all relevant files are tracked and staged, using \`git add ...\` as needed.
+  - \`git diff HEAD\` to review all changes (including unstaged changes) to tracked files in work tree since last commit.
+    - \`git diff --staged\` to review only staged changes when a partial commit makes sense or was requested by the user.
+  - \`git log -n 3\` to review recent commit messages and match their style (verbosity, formatting, signature line, etc.)
+- Combine shell commands whenever possible to save time/steps, e.g. \`git status && git diff HEAD && git log -n 3\`.
+- Always propose a draft commit message. Never just ask the user to give you the full commit message.
+- Prefer commit messages that are clear, concise, and focused more on "why" and less on "what".
+- Keep the user informed and ask for clarification or confirmation where needed.
+- After each commit, confirm that it was successful by running \`git status\`.
+- If a commit fails, never attempt to work around the issues without being asked to do so.
+- Never push changes to a remote repository without being asked explicitly by the user.
+`;
+  }
+  return '';
+})()}
+
+# Examples (Illustrating Tone and Workflow)
+<example>
+user: 1 + 2
+model: 3
+</example>
+
+<example>
+user: is 13 a prime number?
+model: true
+</example>
+
+<example>
+user: start the server implemented in server.js
+model: 
+<tool_call>
+<function=run_shell_command>
+<parameter=command>
+node server.js &
+</parameter>
+</function>
+</tool_call>
+</example>
+
+<example>
+user: Refactor the auth logic in src/auth.py to use the requests library instead of urllib.
+model: Okay, I can refactor 'src/auth.py'.
+First, I'll analyze the code and check for a test safety net before planning any changes.
+<tool_call>
+<function=glob>
+<parameter=path>
+tests/test_auth.py
+</parameter>
+</function>
+</tool_call>
+<tool_call>
+<function=read_file>
+<parameter=path>
+/path/to/tests/test_auth.py
+</parameter>
+<parameter=offset>
+0
+</parameter>
+<parameter=limit>
+10
+</parameter>
+</function>
+</tool_call>
+(After analysis)
+Great, 'tests/test_auth.py' exists and covers the core authentication logic. With this safety net in place, I can safely plan the refactoring.
+I'll also confirm 'requests' is a dependency.
+<tool_call>
+<function=read_file>
+<parameter=path>
+/path/to/requirements.txt
+</parameter>
+</function>
+</tool_call>
+(After analysis)
+Looks good, 'requests' is available.
+
+Here's the plan:
+1.  Replace the 'urllib' calls with 'requests'.
+2.  Add proper 'try...except' error handling for the new network calls.
+3.  Remove the old 'urllib' import.
+4.  Run the project's linter and tests to verify the changes.
+
+<tool_call>
+<function=replace>
+<parameter=path>
+src/auth.py
+</parameter>
+<parameter=old_content>
+(old code content)
+</parameter>
+<parameter=new_content>
+(new code content)
+</parameter>
+</function>
+</tool_call>
+Refactoring complete. Running verification...
+<tool_call>
+<function=run_shell_command
+<parameter=command>
+ruff check src/auth.py && pytest
+</parameter>
+</function>
+</tool_call>
+(After verification passes)
+All checks passed. This is a stable checkpoint.
+Would you like me to write a commit message and commit these changes?
+</example>
+
+<example>
+user: Delete the temp directory.
+model: I can run \`rm -rf /path/to/project/temp\`. This will permanently delete the directory and all its contents.
+</example>
+
+<example>
+user: Write tests for someFile.ts
+model:
+Okay, I can write those tests. First, I'll read someFile.ts to understand its functionality.
+<tool_call>
+<function=read_file>
+<parameter=path>
+/path/to/someFile.ts
+</parameter>
+</function>
+</tool_call>
+Now I'll look for existing or related test files to understand current testing conventions and dependencies.
+<tool_call>
+<function>read_many_files for paths ['**/*.test.ts', 'src/**/*.spec.ts'] assuming someFile.ts is in the src directory]
+</tool_call>
+(After reviewing existing tests and the file content)
+<tool_call>
+<function=write_file>
+<parameter=path>
+/path/to/someFile.test.ts
+</parameter>
+</function>
+</tool_call>
+I've written the tests. Now I'll run the project's test command to verify them.
+<tool_call>
+<function=run_shell_command>
+<parameter=command>
+npm run test
+</parameter>
+</function>
+</tool_call>
+(After verification passes)
+All checks passed. This is a stable checkpoint.
+</example>
+
+<example>
+user: Where are all the 'app.config' files in this project? I need to check their settings.
+model:
+<tool_call>
+<function=glob>
+<parameter=pattern>
+./**/app.config
+</parameter>
+</function>
+</tool_call>
+(Assuming GlobTool returns a list of paths like ['/path/to/moduleA/app.config', '/path/to/moduleB/app.config'])
+I found the following 'app.config' files:
+- /path/to/moduleA/app.config
+- /path/to/moduleB/app.config
+To help you check their settings, I can read their contents. Which one would you like to start with, or should I read all of them?
+</example>
+
+# Final Reminder
+Your core function is efficient and safe assistance. Balance extreme conciseness with the crucial need for clarity, especially regarding safety and potential system modifications. Always prioritize user control and project conventions. Never make assumptions about the contents of files; instead use '${ReadFileTool.Name}' or '${ReadManyFilesTool.Name}' to ensure you aren't making broad assumptions. Finally, you are an agent - please keep going until the user's query is completely resolved.
+`.trim();
+
+  // if GEMINI_WRITE_SYSTEM_MD is set (and not 0|false), write base system prompt to file
+  const writeSystemMdVar = process.env['GEMINI_WRITE_SYSTEM_MD'];
+  if (writeSystemMdVar) {
+    const writeSystemMdVarLower = writeSystemMdVar.toLowerCase();
+    if (!['0', 'false'].includes(writeSystemMdVarLower)) {
+      if (['1', 'true'].includes(writeSystemMdVarLower)) {
+        fs.mkdirSync(path.dirname(systemMdPath), { recursive: true });
+        fs.writeFileSync(systemMdPath, basePrompt); // write to default path, can be modified via GEMINI_SYSTEM_MD
+      } else {
+        let customPath = writeSystemMdVar;
+        if (customPath.startsWith('~/')) {
+          customPath = path.join(os.homedir(), customPath.slice(2));
+        } else if (customPath === '~') {
+          customPath = os.homedir();
+        }
+        const resolvedPath = path.resolve(customPath);
+        fs.mkdirSync(path.dirname(resolvedPath), { recursive: true });
+        fs.writeFileSync(resolvedPath, basePrompt); // write to custom path from GEMINI_WRITE_SYSTEM_MD
+      }
+    }
+  }
+
+  const memorySuffix =
+    userMemory && userMemory.trim().length > 0
+      ? `\n\n---\n\n${userMemory.trim()}`
+      : '';
+
+  return `${basePrompt}${memorySuffix}`;
+}
+
+/**
+ * Provides the system prompt for the history compression process.
+ * This prompt instructs the model to act as a specialized state manager,
+ * think in a scratchpad, and produce a structured XML summary.
+ */
+export function getCompressionPrompt(): string {
+  return `
+You are the component that summarizes internal chat history into a given structure.
+
+When the conversation history grows too large, you will be invoked to distill the entire history into a concise, structured XML snapshot. This snapshot is CRITICAL, as it will become the agent's *only* memory of the past. The agent will resume its work based solely on this snapshot. All crucial details, plans, errors, and user directives MUST be preserved.
+
+First, you will think through the entire history in a private <scratchpad>. Review the user's overall goal, the agent's actions, tool outputs, file modifications, and any unresolved questions. Identify every piece of information that is essential for future actions.
+
+After your reasoning is complete, generate the final <state_snapshot> XML object. Be incredibly dense with information. Omit any irrelevant conversational filler.
+
+The structure MUST be as follows:
+
+<state_snapshot>
+    <overall_goal>
+        <!-- A single, concise sentence describing the user's high-level objective. -->
+        <!-- Example: "Refactor the authentication service to use a new JWT library." -->
+    </overall_goal>
+
+    <key_knowledge>
+        <!-- Crucial facts, conventions, and constraints the agent must remember based on the conversation history and interaction with the user. Use bullet points. -->
+        <!-- Example:
+         - Build Command: \`npm run build\`
+         - Testing: Tests are run with \`npm test\`. Test files must end in \`.test.ts\`.
+         - API Endpoint: The primary API endpoint is \`https://api.example.com/v2\`.
+         
+        -->
+    </key_knowledge>
+
+    <file_system_state>
+        <!-- List files that have been created, read, modified, or deleted. Note their status and critical learnings. -->
+        <!-- Example:
+         - CWD: \`/home/user/project/src\`
+         - READ: \`package.json\` - Confirmed 'axios' is a dependency.
+         - MODIFIED: \`services/auth.ts\` - Replaced 'jsonwebtoken' with 'jose'.
+         - CREATED: \`tests/new-feature.test.ts\` - Initial test structure for the new feature.
+        -->
+    </file_system_state>
+
+    <recent_actions>
+        <!-- A summary of the last few significant agent actions and their outcomes. Focus on facts. -->
+        <!-- Example:
+         - Ran \`grep 'old_function'\` which returned 3 results in 2 files.
+         - Ran \`npm run test\`, which failed due to a snapshot mismatch in \`UserProfile.test.ts\`.
+         - Ran \`ls -F static/\` and discovered image assets are stored as \`.webp\`.
+        -->
+    </recent_actions>
+
+    <current_plan>
+        <!-- The agent's step-by-step plan. Mark completed steps. -->
+        <!-- Example:
+         1. [DONE] Identify all files using the deprecated 'UserAPI'.
+         2. [IN PROGRESS] Refactor \`src/components/UserProfile.tsx\` to use the new 'ProfileAPI'.
+         3. [TODO] Refactor the remaining files.
+         4. [TODO] Update tests to reflect the API change.
+        -->
+    </current_plan>
+</state_snapshot>
+`.trim();
+}

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

@@ -0,0 +1,813 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { vi, describe, it, expect, beforeEach, Mock, afterEach } from 'vitest';
+import {
+  ContextState,
+  SubAgentScope,
+  SubagentTerminateMode,
+  PromptConfig,
+  ModelConfig,
+  RunConfig,
+  OutputConfig,
+  ToolConfig,
+} from './subagent.js';
+import { Config, ConfigParameters } from '../config/config.js';
+import { GeminiChat } from './geminiChat.js';
+import { createContentGenerator } from './contentGenerator.js';
+import { getEnvironmentContext } from '../utils/environmentContext.js';
+import { executeToolCall } from './nonInteractiveToolExecutor.js';
+import { ToolRegistry } from '../tools/tool-registry.js';
+import { DEFAULT_GEMINI_MODEL } from '../config/models.js';
+import {
+  Content,
+  FunctionCall,
+  FunctionDeclaration,
+  GenerateContentConfig,
+  Type,
+} from '@google/genai';
+import { ToolErrorType } from '../tools/tool-error.js';
+
+vi.mock('./geminiChat.js');
+vi.mock('./contentGenerator.js');
+vi.mock('../utils/environmentContext.js');
+vi.mock('./nonInteractiveToolExecutor.js');
+vi.mock('../ide/ide-client.js');
+
+async function createMockConfig(
+  toolRegistryMocks = {},
+): Promise<{ config: Config; toolRegistry: ToolRegistry }> {
+  const configParams: ConfigParameters = {
+    sessionId: 'test-session',
+    model: DEFAULT_GEMINI_MODEL,
+    targetDir: '.',
+    debugMode: false,
+    cwd: process.cwd(),
+  };
+  const config = new Config(configParams);
+  await config.initialize();
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  await config.refreshAuth('test-auth' as any);
+
+  // Mock ToolRegistry
+  const mockToolRegistry = {
+    getTool: vi.fn(),
+    getFunctionDeclarationsFiltered: vi.fn().mockReturnValue([]),
+    ...toolRegistryMocks,
+  } as unknown as ToolRegistry;
+
+  vi.spyOn(config, 'getToolRegistry').mockReturnValue(mockToolRegistry);
+  return { config, toolRegistry: mockToolRegistry };
+}
+
+// Helper to simulate LLM responses (sequence of tool calls over multiple turns)
+const createMockStream = (
+  functionCallsList: Array<FunctionCall[] | 'stop'>,
+) => {
+  let index = 0;
+  return vi.fn().mockImplementation(() => {
+    const response = functionCallsList[index] || 'stop';
+    index++;
+    return (async function* () {
+      if (response === 'stop') {
+        // When stopping, the model might return text, but the subagent logic primarily cares about the absence of functionCalls.
+        yield { text: 'Done.' };
+      } else if (response.length > 0) {
+        yield { functionCalls: response };
+      } else {
+        yield { text: 'Done.' }; // Handle empty array also as stop
+      }
+    })();
+  });
+};
+
+describe('subagent.ts', () => {
+  describe('ContextState', () => {
+    it('should set and get values correctly', () => {
+      const context = new ContextState();
+      context.set('key1', 'value1');
+      context.set('key2', 123);
+      expect(context.get('key1')).toBe('value1');
+      expect(context.get('key2')).toBe(123);
+      expect(context.get_keys()).toEqual(['key1', 'key2']);
+    });
+
+    it('should return undefined for missing keys', () => {
+      const context = new ContextState();
+      expect(context.get('missing')).toBeUndefined();
+    });
+  });
+
+  describe('SubAgentScope', () => {
+    let mockSendMessageStream: Mock;
+
+    const defaultModelConfig: ModelConfig = {
+      model: 'gemini-1.5-flash-latest',
+      temp: 0.5, // Specific temp to test override
+      top_p: 1,
+    };
+
+    const defaultRunConfig: RunConfig = {
+      max_time_minutes: 5,
+      max_turns: 10,
+    };
+
+    beforeEach(async () => {
+      vi.clearAllMocks();
+
+      vi.mocked(getEnvironmentContext).mockResolvedValue([
+        { text: 'Env Context' },
+      ]);
+      vi.mocked(createContentGenerator).mockResolvedValue({
+        getGenerativeModel: vi.fn(),
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      } as any);
+
+      mockSendMessageStream = vi.fn();
+      // We mock the implementation of the constructor.
+      vi.mocked(GeminiChat).mockImplementation(
+        () =>
+          ({
+            sendMessageStream: mockSendMessageStream,
+          }) as unknown as GeminiChat,
+      );
+    });
+
+    afterEach(() => {
+      vi.restoreAllMocks();
+    });
+
+    // Helper to safely access generationConfig from mock calls
+    const getGenerationConfigFromMock = (
+      callIndex = 0,
+    ): GenerateContentConfig & { systemInstruction?: string | Content } => {
+      const callArgs = vi.mocked(GeminiChat).mock.calls[callIndex];
+      const generationConfig = callArgs?.[2];
+      // Ensure it's defined before proceeding
+      expect(generationConfig).toBeDefined();
+      if (!generationConfig) throw new Error('generationConfig is undefined');
+      return generationConfig as GenerateContentConfig & {
+        systemInstruction?: string | Content;
+      };
+    };
+
+    describe('create (Tool Validation)', () => {
+      const promptConfig: PromptConfig = { systemPrompt: 'Test prompt' };
+
+      it('should create a SubAgentScope successfully with minimal config', async () => {
+        const { config } = await createMockConfig();
+        const scope = await SubAgentScope.create(
+          'test-agent',
+          config,
+          promptConfig,
+          defaultModelConfig,
+          defaultRunConfig,
+        );
+        expect(scope).toBeInstanceOf(SubAgentScope);
+      });
+
+      it('should throw an error if a tool requires confirmation', async () => {
+        const mockTool = {
+          schema: { parameters: { type: Type.OBJECT, properties: {} } },
+          build: vi.fn().mockReturnValue({
+            shouldConfirmExecute: vi.fn().mockResolvedValue({
+              type: 'exec',
+              title: 'Confirm',
+              command: 'rm -rf /',
+            }),
+          }),
+        };
+
+        const { config } = await createMockConfig({
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          getTool: vi.fn().mockReturnValue(mockTool as any),
+        });
+
+        const toolConfig: ToolConfig = { tools: ['risky_tool'] };
+
+        await expect(
+          SubAgentScope.create(
+            'test-agent',
+            config,
+            promptConfig,
+            defaultModelConfig,
+            defaultRunConfig,
+            toolConfig,
+          ),
+        ).rejects.toThrow(
+          'Tool "risky_tool" requires user confirmation and cannot be used in a non-interactive subagent.',
+        );
+      });
+
+      it('should succeed if tools do not require confirmation', async () => {
+        const mockTool = {
+          schema: { parameters: { type: Type.OBJECT, properties: {} } },
+          build: vi.fn().mockReturnValue({
+            shouldConfirmExecute: vi.fn().mockResolvedValue(null),
+          }),
+        };
+        const { config } = await createMockConfig({
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          getTool: vi.fn().mockReturnValue(mockTool as any),
+        });
+
+        const toolConfig: ToolConfig = { tools: ['safe_tool'] };
+
+        const scope = await SubAgentScope.create(
+          'test-agent',
+          config,
+          promptConfig,
+          defaultModelConfig,
+          defaultRunConfig,
+          toolConfig,
+        );
+        expect(scope).toBeInstanceOf(SubAgentScope);
+      });
+
+      it('should skip interactivity check and warn for tools with required parameters', async () => {
+        const consoleWarnSpy = vi
+          .spyOn(console, 'warn')
+          .mockImplementation(() => {});
+
+        const mockToolWithParams = {
+          schema: {
+            parameters: {
+              type: Type.OBJECT,
+              properties: {
+                path: { type: Type.STRING },
+              },
+              required: ['path'],
+            },
+          },
+          // build should not be called, but we mock it to be safe
+          build: vi.fn(),
+        };
+
+        const { config } = await createMockConfig({
+          getTool: vi.fn().mockReturnValue(mockToolWithParams),
+        });
+
+        const toolConfig: ToolConfig = { tools: ['tool_with_params'] };
+
+        // The creation should succeed without throwing
+        const scope = await SubAgentScope.create(
+          'test-agent',
+          config,
+          promptConfig,
+          defaultModelConfig,
+          defaultRunConfig,
+          toolConfig,
+        );
+
+        expect(scope).toBeInstanceOf(SubAgentScope);
+
+        // Check that the warning was logged
+        expect(consoleWarnSpy).toHaveBeenCalledWith(
+          'Cannot check tool "tool_with_params" for interactivity because it requires parameters. Assuming it is safe for non-interactive use.',
+        );
+
+        // Ensure build was never called
+        expect(mockToolWithParams.build).not.toHaveBeenCalled();
+
+        consoleWarnSpy.mockRestore();
+      });
+    });
+
+    describe('runNonInteractive - Initialization and Prompting', () => {
+      it('should correctly template the system prompt and initialize GeminiChat', async () => {
+        const { config } = await createMockConfig();
+
+        vi.mocked(GeminiChat).mockClear();
+
+        const promptConfig: PromptConfig = {
+          systemPrompt: 'Hello ${name}, your task is ${task}.',
+        };
+        const context = new ContextState();
+        context.set('name', 'Agent');
+        context.set('task', 'Testing');
+
+        // Model stops immediately
+        mockSendMessageStream.mockImplementation(createMockStream(['stop']));
+
+        const scope = await SubAgentScope.create(
+          'test-agent',
+          config,
+          promptConfig,
+          defaultModelConfig,
+          defaultRunConfig,
+        );
+
+        await scope.runNonInteractive(context);
+
+        // Check if GeminiChat was initialized correctly by the subagent
+        expect(GeminiChat).toHaveBeenCalledTimes(1);
+        const callArgs = vi.mocked(GeminiChat).mock.calls[0];
+
+        // Check Generation Config
+        const generationConfig = getGenerationConfigFromMock();
+
+        // Check temperature override
+        expect(generationConfig.temperature).toBe(defaultModelConfig.temp);
+        expect(generationConfig.systemInstruction).toContain(
+          'Hello Agent, your task is Testing.',
+        );
+        expect(generationConfig.systemInstruction).toContain(
+          'Important Rules:',
+        );
+
+        // Check History (should include environment context)
+        const history = callArgs[3];
+        expect(history).toEqual([
+          { role: 'user', parts: [{ text: 'Env Context' }] },
+          {
+            role: 'model',
+            parts: [{ text: 'Got it. Thanks for the context!' }],
+          },
+        ]);
+      });
+
+      it('should include output instructions in the system prompt when outputs are defined', async () => {
+        const { config } = await createMockConfig();
+        vi.mocked(GeminiChat).mockClear();
+
+        const promptConfig: PromptConfig = { systemPrompt: 'Do the task.' };
+        const outputConfig: OutputConfig = {
+          outputs: {
+            result1: 'The first result',
+          },
+        };
+        const context = new ContextState();
+
+        // Model stops immediately
+        mockSendMessageStream.mockImplementation(createMockStream(['stop']));
+
+        const scope = await SubAgentScope.create(
+          'test-agent',
+          config,
+          promptConfig,
+          defaultModelConfig,
+          defaultRunConfig,
+          undefined, // ToolConfig
+          outputConfig,
+        );
+
+        await scope.runNonInteractive(context);
+
+        const generationConfig = getGenerationConfigFromMock();
+        const systemInstruction = generationConfig.systemInstruction as string;
+
+        expect(systemInstruction).toContain('Do the task.');
+        expect(systemInstruction).toContain(
+          'you MUST emit the required output variables',
+        );
+        expect(systemInstruction).toContain(
+          "Use 'self.emitvalue' to emit the 'result1' key",
+        );
+      });
+
+      it('should use initialMessages instead of systemPrompt if provided', async () => {
+        const { config } = await createMockConfig();
+        vi.mocked(GeminiChat).mockClear();
+
+        const initialMessages: Content[] = [
+          { role: 'user', parts: [{ text: 'Hi' }] },
+        ];
+        const promptConfig: PromptConfig = { initialMessages };
+        const context = new ContextState();
+
+        // Model stops immediately
+        mockSendMessageStream.mockImplementation(createMockStream(['stop']));
+
+        const scope = await SubAgentScope.create(
+          'test-agent',
+          config,
+          promptConfig,
+          defaultModelConfig,
+          defaultRunConfig,
+        );
+
+        await scope.runNonInteractive(context);
+
+        const callArgs = vi.mocked(GeminiChat).mock.calls[0];
+        const generationConfig = getGenerationConfigFromMock();
+        const history = callArgs[3];
+
+        expect(generationConfig.systemInstruction).toBeUndefined();
+        expect(history).toEqual([
+          { role: 'user', parts: [{ text: 'Env Context' }] },
+          {
+            role: 'model',
+            parts: [{ text: 'Got it. Thanks for the context!' }],
+          },
+          ...initialMessages,
+        ]);
+      });
+
+      it('should throw an error if template variables are missing', async () => {
+        const { config } = await createMockConfig();
+        const promptConfig: PromptConfig = {
+          systemPrompt: 'Hello ${name}, you are missing ${missing}.',
+        };
+        const context = new ContextState();
+        context.set('name', 'Agent');
+        // 'missing' is not set
+
+        const scope = await SubAgentScope.create(
+          'test-agent',
+          config,
+          promptConfig,
+          defaultModelConfig,
+          defaultRunConfig,
+        );
+
+        // The error from templating causes the runNonInteractive to reject and the terminate_reason to be ERROR.
+        await expect(scope.runNonInteractive(context)).rejects.toThrow(
+          'Missing context values for the following keys: missing',
+        );
+        expect(scope.output.terminate_reason).toBe(SubagentTerminateMode.ERROR);
+      });
+
+      it('should validate that systemPrompt and initialMessages are mutually exclusive', async () => {
+        const { config } = await createMockConfig();
+        const promptConfig: PromptConfig = {
+          systemPrompt: 'System',
+          initialMessages: [{ role: 'user', parts: [{ text: 'Hi' }] }],
+        };
+        const context = new ContextState();
+
+        const agent = await SubAgentScope.create(
+          'TestAgent',
+          config,
+          promptConfig,
+          defaultModelConfig,
+          defaultRunConfig,
+        );
+
+        await expect(agent.runNonInteractive(context)).rejects.toThrow(
+          'PromptConfig cannot have both `systemPrompt` and `initialMessages` defined.',
+        );
+        expect(agent.output.terminate_reason).toBe(SubagentTerminateMode.ERROR);
+      });
+    });
+
+    describe('runNonInteractive - Execution and Tool Use', () => {
+      const promptConfig: PromptConfig = { systemPrompt: 'Execute task.' };
+
+      it('should terminate with GOAL if no outputs are expected and model stops', async () => {
+        const { config } = await createMockConfig();
+        // Model stops immediately
+        mockSendMessageStream.mockImplementation(createMockStream(['stop']));
+
+        const scope = await SubAgentScope.create(
+          'test-agent',
+          config,
+          promptConfig,
+          defaultModelConfig,
+          defaultRunConfig,
+          // No ToolConfig, No OutputConfig
+        );
+
+        await scope.runNonInteractive(new ContextState());
+
+        expect(scope.output.terminate_reason).toBe(SubagentTerminateMode.GOAL);
+        expect(scope.output.emitted_vars).toEqual({});
+        expect(mockSendMessageStream).toHaveBeenCalledTimes(1);
+        // Check the initial message
+        expect(mockSendMessageStream.mock.calls[0][0].message).toEqual([
+          { text: 'Get Started!' },
+        ]);
+      });
+
+      it('should handle self.emitvalue and terminate with GOAL when outputs are met', async () => {
+        const { config } = await createMockConfig();
+        const outputConfig: OutputConfig = {
+          outputs: { result: 'The final result' },
+        };
+
+        // Turn 1: Model responds with emitvalue call
+        // Turn 2: Model stops after receiving the tool response
+        mockSendMessageStream.mockImplementation(
+          createMockStream([
+            [
+              {
+                name: 'self.emitvalue',
+                args: {
+                  emit_variable_name: 'result',
+                  emit_variable_value: 'Success!',
+                },
+              },
+            ],
+            'stop',
+          ]),
+        );
+
+        const scope = await SubAgentScope.create(
+          'test-agent',
+          config,
+          promptConfig,
+          defaultModelConfig,
+          defaultRunConfig,
+          undefined,
+          outputConfig,
+        );
+
+        await scope.runNonInteractive(new ContextState());
+
+        expect(scope.output.terminate_reason).toBe(SubagentTerminateMode.GOAL);
+        expect(scope.output.emitted_vars).toEqual({ result: 'Success!' });
+        expect(mockSendMessageStream).toHaveBeenCalledTimes(2);
+
+        // Check the tool response sent back in the second call
+        const secondCallArgs = mockSendMessageStream.mock.calls[1][0];
+        expect(secondCallArgs.message).toEqual([
+          { text: 'Emitted variable result successfully' },
+        ]);
+      });
+
+      it('should execute external tools and provide the response to the model', async () => {
+        const listFilesToolDef: FunctionDeclaration = {
+          name: 'list_files',
+          description: 'Lists files',
+          parameters: { type: Type.OBJECT, properties: {} },
+        };
+
+        const { config } = await createMockConfig({
+          getFunctionDeclarationsFiltered: vi
+            .fn()
+            .mockReturnValue([listFilesToolDef]),
+        });
+        const toolConfig: ToolConfig = { tools: ['list_files'] };
+
+        // Turn 1: Model calls the external tool
+        // Turn 2: Model stops
+        mockSendMessageStream.mockImplementation(
+          createMockStream([
+            [
+              {
+                id: 'call_1',
+                name: 'list_files',
+                args: { path: '.' },
+              },
+            ],
+            'stop',
+          ]),
+        );
+
+        // Mock the tool execution result
+        vi.mocked(executeToolCall).mockResolvedValue({
+          callId: 'call_1',
+          responseParts: 'file1.txt\nfile2.ts',
+          resultDisplay: 'Listed 2 files',
+          error: undefined,
+          errorType: undefined, // Or ToolErrorType.NONE if available and appropriate
+        });
+
+        const scope = await SubAgentScope.create(
+          'test-agent',
+          config,
+          promptConfig,
+          defaultModelConfig,
+          defaultRunConfig,
+          toolConfig,
+        );
+
+        await scope.runNonInteractive(new ContextState());
+
+        // Check tool execution
+        expect(executeToolCall).toHaveBeenCalledWith(
+          config,
+          expect.objectContaining({ name: 'list_files', args: { path: '.' } }),
+          expect.any(AbortSignal),
+        );
+
+        // Check the response sent back to the model
+        const secondCallArgs = mockSendMessageStream.mock.calls[1][0];
+        expect(secondCallArgs.message).toEqual([
+          { text: 'file1.txt\nfile2.ts' },
+        ]);
+
+        expect(scope.output.terminate_reason).toBe(SubagentTerminateMode.GOAL);
+      });
+
+      it('should provide specific tool error responses to the model', async () => {
+        const { config } = await createMockConfig();
+        const toolConfig: ToolConfig = { tools: ['failing_tool'] };
+
+        // Turn 1: Model calls the failing tool
+        // Turn 2: Model stops after receiving the error response
+        mockSendMessageStream.mockImplementation(
+          createMockStream([
+            [
+              {
+                id: 'call_fail',
+                name: 'failing_tool',
+                args: {},
+              },
+            ],
+            'stop',
+          ]),
+        );
+
+        // Mock the tool execution failure.
+        vi.mocked(executeToolCall).mockResolvedValue({
+          callId: 'call_fail',
+          responseParts: 'ERROR: Tool failed catastrophically', // This should be sent to the model
+          resultDisplay: 'Tool failed catastrophically',
+          error: new Error('Failure'),
+          errorType: ToolErrorType.INVALID_TOOL_PARAMS,
+        });
+
+        const scope = await SubAgentScope.create(
+          'test-agent',
+          config,
+          promptConfig,
+          defaultModelConfig,
+          defaultRunConfig,
+          toolConfig,
+        );
+
+        await scope.runNonInteractive(new ContextState());
+
+        // The agent should send the specific error message from responseParts.
+        const secondCallArgs = mockSendMessageStream.mock.calls[1][0];
+
+        expect(secondCallArgs.message).toEqual([
+          {
+            text: 'ERROR: Tool failed catastrophically',
+          },
+        ]);
+      });
+
+      it('should nudge the model if it stops before emitting all required variables', async () => {
+        const { config } = await createMockConfig();
+        const outputConfig: OutputConfig = {
+          outputs: { required_var: 'Must be present' },
+        };
+
+        // Turn 1: Model stops prematurely
+        // Turn 2: Model responds to the nudge and emits the variable
+        // Turn 3: Model stops
+        mockSendMessageStream.mockImplementation(
+          createMockStream([
+            'stop',
+            [
+              {
+                name: 'self.emitvalue',
+                args: {
+                  emit_variable_name: 'required_var',
+                  emit_variable_value: 'Here it is',
+                },
+              },
+            ],
+            'stop',
+          ]),
+        );
+
+        const scope = await SubAgentScope.create(
+          'test-agent',
+          config,
+          promptConfig,
+          defaultModelConfig,
+          defaultRunConfig,
+          undefined,
+          outputConfig,
+        );
+
+        await scope.runNonInteractive(new ContextState());
+
+        // Check the nudge message sent in Turn 2
+        const secondCallArgs = mockSendMessageStream.mock.calls[1][0];
+
+        // We check that the message contains the required variable name and the nudge phrasing.
+        expect(secondCallArgs.message[0].text).toContain('required_var');
+        expect(secondCallArgs.message[0].text).toContain(
+          'You have stopped calling tools',
+        );
+
+        expect(scope.output.terminate_reason).toBe(SubagentTerminateMode.GOAL);
+        expect(scope.output.emitted_vars).toEqual({
+          required_var: 'Here it is',
+        });
+        expect(mockSendMessageStream).toHaveBeenCalledTimes(3);
+      });
+    });
+
+    describe('runNonInteractive - Termination and Recovery', () => {
+      const promptConfig: PromptConfig = { systemPrompt: 'Execute task.' };
+
+      it('should terminate with MAX_TURNS if the limit is reached', async () => {
+        const { config } = await createMockConfig();
+        const runConfig: RunConfig = { ...defaultRunConfig, max_turns: 2 };
+
+        // Model keeps looping by calling emitvalue repeatedly
+        mockSendMessageStream.mockImplementation(
+          createMockStream([
+            [
+              {
+                name: 'self.emitvalue',
+                args: { emit_variable_name: 'loop', emit_variable_value: 'v1' },
+              },
+            ],
+            [
+              {
+                name: 'self.emitvalue',
+                args: { emit_variable_name: 'loop', emit_variable_value: 'v2' },
+              },
+            ],
+            // This turn should not happen
+            [
+              {
+                name: 'self.emitvalue',
+                args: { emit_variable_name: 'loop', emit_variable_value: 'v3' },
+              },
+            ],
+          ]),
+        );
+
+        const scope = await SubAgentScope.create(
+          'test-agent',
+          config,
+          promptConfig,
+          defaultModelConfig,
+          runConfig,
+        );
+
+        await scope.runNonInteractive(new ContextState());
+
+        expect(mockSendMessageStream).toHaveBeenCalledTimes(2);
+        expect(scope.output.terminate_reason).toBe(
+          SubagentTerminateMode.MAX_TURNS,
+        );
+      });
+
+      it('should terminate with TIMEOUT if the time limit is reached during an LLM call', async () => {
+        // Use fake timers to reliably test timeouts
+        vi.useFakeTimers();
+
+        const { config } = await createMockConfig();
+        const runConfig: RunConfig = { max_time_minutes: 5, max_turns: 100 };
+
+        // We need to control the resolution of the sendMessageStream promise to advance the timer during execution.
+        let resolveStream: (
+          value: AsyncGenerator<unknown, void, unknown>,
+        ) => void;
+        const streamPromise = new Promise<
+          AsyncGenerator<unknown, void, unknown>
+        >((resolve) => {
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolveStream = resolve as any;
+        });
+
+        // The LLM call will hang until we resolve the promise.
+        mockSendMessageStream.mockReturnValue(streamPromise);
+
+        const scope = await SubAgentScope.create(
+          'test-agent',
+          config,
+          promptConfig,
+          defaultModelConfig,
+          runConfig,
+        );
+
+        const runPromise = scope.runNonInteractive(new ContextState());
+
+        // Advance time beyond the limit (6 minutes) while the agent is awaiting the LLM response.
+        await vi.advanceTimersByTimeAsync(6 * 60 * 1000);
+
+        // Now resolve the stream. The model returns 'stop'.
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        resolveStream!(createMockStream(['stop'])() as any);
+
+        await runPromise;
+
+        expect(scope.output.terminate_reason).toBe(
+          SubagentTerminateMode.TIMEOUT,
+        );
+        expect(mockSendMessageStream).toHaveBeenCalledTimes(1);
+
+        vi.useRealTimers();
+      });
+
+      it('should terminate with ERROR if the model call throws', async () => {
+        const { config } = await createMockConfig();
+        mockSendMessageStream.mockRejectedValue(new Error('API Failure'));
+
+        const scope = await SubAgentScope.create(
+          'test-agent',
+          config,
+          promptConfig,
+          defaultModelConfig,
+          defaultRunConfig,
+        );
+
+        await expect(
+          scope.runNonInteractive(new ContextState()),
+        ).rejects.toThrow('API Failure');
+        expect(scope.output.terminate_reason).toBe(SubagentTerminateMode.ERROR);
+      });
+    });
+  });
+});

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

@@ -0,0 +1,676 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { reportError } from '../utils/errorReporting.js';
+import { Config } from '../config/config.js';
+import { ToolCallRequestInfo } from './turn.js';
+import { executeToolCall } from './nonInteractiveToolExecutor.js';
+import { createContentGenerator } from './contentGenerator.js';
+import { getEnvironmentContext } from '../utils/environmentContext.js';
+import {
+  Content,
+  Part,
+  FunctionCall,
+  GenerateContentConfig,
+  FunctionDeclaration,
+  Type,
+} from '@google/genai';
+import { GeminiChat } from './geminiChat.js';
+
+/**
+ * @fileoverview Defines the configuration interfaces for a subagent.
+ *
+ * These interfaces specify the structure for defining the subagent's prompt,
+ * the model parameters, and the execution settings.
+ */
+
+/**
+ * Describes the possible termination modes for a subagent.
+ * This enum provides a clear indication of why a subagent's execution might have ended.
+ */
+export enum SubagentTerminateMode {
+  /**
+   * Indicates that the subagent's execution terminated due to an unrecoverable error.
+   */
+  ERROR = 'ERROR',
+  /**
+   * Indicates that the subagent's execution terminated because it exceeded the maximum allowed working time.
+   */
+  TIMEOUT = 'TIMEOUT',
+  /**
+   * Indicates that the subagent's execution successfully completed all its defined goals.
+   */
+  GOAL = 'GOAL',
+  /**
+   * Indicates that the subagent's execution terminated because it exceeded the maximum number of turns.
+   */
+  MAX_TURNS = 'MAX_TURNS',
+}
+
+/**
+ * Represents the output structure of a subagent's execution.
+ * This interface defines the data that a subagent will return upon completion,
+ * including any emitted variables and the reason for its termination.
+ */
+export interface OutputObject {
+  /**
+   * A record of key-value pairs representing variables emitted by the subagent
+   * during its execution. These variables can be used by the calling agent.
+   */
+  emitted_vars: Record<string, string>;
+  /**
+   * The reason for the subagent's termination, indicating whether it completed
+   * successfully, timed out, or encountered an error.
+   */
+  terminate_reason: SubagentTerminateMode;
+}
+
+/**
+ * Configures the initial prompt for the subagent.
+ */
+export interface PromptConfig {
+  /**
+   * A single system prompt string that defines the subagent's persona and instructions.
+   * Note: You should use either `systemPrompt` or `initialMessages`, but not both.
+   */
+  systemPrompt?: string;
+
+  /**
+   * An array of user/model content pairs to seed the chat history for few-shot prompting.
+   * Note: You should use either `systemPrompt` or `initialMessages`, but not both.
+   */
+  initialMessages?: Content[];
+}
+
+/**
+ * Configures the tools available to the subagent during its execution.
+ */
+export interface ToolConfig {
+  /**
+   * A list of tool names (from the tool registry) or full function declarations
+   * that the subagent is permitted to use.
+   */
+  tools: Array<string | FunctionDeclaration>;
+}
+
+/**
+ * Configures the expected outputs for the subagent.
+ */
+export interface OutputConfig {
+  /**
+   * A record describing the variables the subagent is expected to emit.
+   * The subagent will be prompted to generate these values before terminating.
+   */
+  outputs: Record<string, string>;
+}
+
+/**
+ * Configures the generative model parameters for the subagent.
+ * This interface specifies the model to be used and its associated generation settings,
+ * such as temperature and top-p values, which influence the creativity and diversity of the model's output.
+ */
+export interface ModelConfig {
+  /**
+   * The name or identifier of the model to be used (e.g., 'gemini-2.5-pro').
+   *
+   * TODO: In the future, this needs to support 'auto' or some other string to support routing use cases.
+   */
+  model: string;
+  /**
+   * The temperature for the model's sampling process.
+   */
+  temp: number;
+  /**
+   * The top-p value for nucleus sampling.
+   */
+  top_p: number;
+}
+
+/**
+ * Configures the execution environment and constraints for the subagent.
+ * This interface defines parameters that control the subagent's runtime behavior,
+ * such as maximum execution time, to prevent infinite loops or excessive resource consumption.
+ *
+ * TODO: Consider adding max_tokens as a form of budgeting.
+ */
+export interface RunConfig {
+  /** The maximum execution time for the subagent in minutes. */
+  max_time_minutes: number;
+  /**
+   * The maximum number of conversational turns (a user message + model response)
+   * before the execution is terminated. Helps prevent infinite loops.
+   */
+  max_turns?: number;
+}
+
+/**
+ * Manages the runtime context state for the subagent.
+ * This class provides a mechanism to store and retrieve key-value pairs
+ * that represent the dynamic state and variables accessible to the subagent
+ * during its execution.
+ */
+export class ContextState {
+  private state: Record<string, unknown> = {};
+
+  /**
+   * Retrieves a value from the context state.
+   *
+   * @param key - The key of the value to retrieve.
+   * @returns The value associated with the key, or undefined if the key is not found.
+   */
+  get(key: string): unknown {
+    return this.state[key];
+  }
+
+  /**
+   * Sets a value in the context state.
+   *
+   * @param key - The key to set the value under.
+   * @param value - The value to set.
+   */
+  set(key: string, value: unknown): void {
+    this.state[key] = value;
+  }
+
+  /**
+   * Retrieves all keys in the context state.
+   *
+   * @returns An array of all keys in the context state.
+   */
+  get_keys(): string[] {
+    return Object.keys(this.state);
+  }
+}
+
+/**
+ * Replaces `${...}` placeholders in a template string with values from a context.
+ *
+ * This function identifies all placeholders in the format `${key}`, validates that
+ * each key exists in the provided `ContextState`, and then performs the substitution.
+ *
+ * @param template The template string containing placeholders.
+ * @param context The `ContextState` object providing placeholder values.
+ * @returns The populated string with all placeholders replaced.
+ * @throws {Error} if any placeholder key is not found in the context.
+ */
+function templateString(template: string, context: ContextState): string {
+  const placeholderRegex = /\$\{(\w+)\}/g;
+
+  // First, find all unique keys required by the template.
+  const requiredKeys = new Set(
+    Array.from(template.matchAll(placeholderRegex), (match) => match[1]),
+  );
+
+  // Check if all required keys exist in the context.
+  const contextKeys = new Set(context.get_keys());
+  const missingKeys = Array.from(requiredKeys).filter(
+    (key) => !contextKeys.has(key),
+  );
+
+  if (missingKeys.length > 0) {
+    throw new Error(
+      `Missing context values for the following keys: ${missingKeys.join(
+        ', ',
+      )}`,
+    );
+  }
+
+  // Perform the replacement using a replacer function.
+  return template.replace(placeholderRegex, (_match, key) =>
+    String(context.get(key)),
+  );
+}
+
+/**
+ * Represents the scope and execution environment for a subagent.
+ * This class orchestrates the subagent's lifecycle, managing its chat interactions,
+ * runtime context, and the collection of its outputs.
+ */
+export class SubAgentScope {
+  output: OutputObject = {
+    terminate_reason: SubagentTerminateMode.ERROR,
+    emitted_vars: {},
+  };
+  private readonly subagentId: string;
+
+  /**
+   * Constructs a new SubAgentScope instance.
+   * @param name - The name for the subagent, used for logging and identification.
+   * @param runtimeContext - The shared runtime configuration and services.
+   * @param promptConfig - Configuration for the subagent's prompt and behavior.
+   * @param modelConfig - Configuration for the generative model parameters.
+   * @param runConfig - Configuration for the subagent's execution environment.
+   * @param toolConfig - Optional configuration for tools available to the subagent.
+   * @param outputConfig - Optional configuration for the subagent's expected outputs.
+   */
+  private constructor(
+    readonly name: string,
+    readonly runtimeContext: Config,
+    private readonly promptConfig: PromptConfig,
+    private readonly modelConfig: ModelConfig,
+    private readonly runConfig: RunConfig,
+    private readonly toolConfig?: ToolConfig,
+    private readonly outputConfig?: OutputConfig,
+  ) {
+    const randomPart = Math.random().toString(36).slice(2, 8);
+    this.subagentId = `${this.name}-${randomPart}`;
+  }
+
+  /**
+   * Creates and validates a new SubAgentScope instance.
+   * This factory method ensures that all tools provided in the prompt configuration
+   * are valid for non-interactive use before creating the subagent instance.
+   * @param {string} name - The name of the subagent.
+   * @param {Config} runtimeContext - The shared runtime configuration and services.
+   * @param {PromptConfig} promptConfig - Configuration for the subagent's prompt and behavior.
+   * @param {ModelConfig} modelConfig - Configuration for the generative model parameters.
+   * @param {RunConfig} runConfig - Configuration for the subagent's execution environment.
+   * @param {ToolConfig} [toolConfig] - Optional configuration for tools.
+   * @param {OutputConfig} [outputConfig] - Optional configuration for expected outputs.
+   * @returns {Promise<SubAgentScope>} A promise that resolves to a valid SubAgentScope instance.
+   * @throws {Error} If any tool requires user confirmation.
+   */
+  static async create(
+    name: string,
+    runtimeContext: Config,
+    promptConfig: PromptConfig,
+    modelConfig: ModelConfig,
+    runConfig: RunConfig,
+    toolConfig?: ToolConfig,
+    outputConfig?: OutputConfig,
+  ): Promise<SubAgentScope> {
+    if (toolConfig) {
+      const toolRegistry = runtimeContext.getToolRegistry();
+      const toolsToLoad: string[] = [];
+      for (const tool of toolConfig.tools) {
+        if (typeof tool === 'string') {
+          toolsToLoad.push(tool);
+        }
+      }
+
+      for (const toolName of toolsToLoad) {
+        const tool = toolRegistry.getTool(toolName);
+        if (tool) {
+          const requiredParams = tool.schema.parameters?.required ?? [];
+          if (requiredParams.length > 0) {
+            // This check is imperfect. A tool might require parameters but still
+            // be interactive (e.g., `delete_file(path)`). However, we cannot
+            // build a generic invocation without knowing what dummy parameters
+            // to provide. Crashing here because `build({})` fails is worse
+            // than allowing a potential hang later if an interactive tool is
+            // used. This is a best-effort check.
+            console.warn(
+              `Cannot check tool "${toolName}" for interactivity because it requires parameters. Assuming it is safe for non-interactive use.`,
+            );
+            continue;
+          }
+
+          const invocation = tool.build({});
+          const confirmationDetails = await invocation.shouldConfirmExecute(
+            new AbortController().signal,
+          );
+          if (confirmationDetails) {
+            throw new Error(
+              `Tool "${toolName}" requires user confirmation and cannot be used in a non-interactive subagent.`,
+            );
+          }
+        }
+      }
+    }
+
+    return new SubAgentScope(
+      name,
+      runtimeContext,
+      promptConfig,
+      modelConfig,
+      runConfig,
+      toolConfig,
+      outputConfig,
+    );
+  }
+
+  /**
+   * Runs the subagent in a non-interactive mode.
+   * This method orchestrates the subagent's execution loop, including prompt templating,
+   * tool execution, and termination conditions.
+   * @param {ContextState} context - The current context state containing variables for prompt templating.
+   * @returns {Promise<void>} A promise that resolves when the subagent has completed its execution.
+   */
+  async runNonInteractive(context: ContextState): Promise<void> {
+    const chat = await this.createChatObject(context);
+
+    if (!chat) {
+      this.output.terminate_reason = SubagentTerminateMode.ERROR;
+      return;
+    }
+
+    const abortController = new AbortController();
+    const toolRegistry = this.runtimeContext.getToolRegistry();
+
+    // Prepare the list of tools available to the subagent.
+    const toolsList: FunctionDeclaration[] = [];
+    if (this.toolConfig) {
+      const toolsToLoad: string[] = [];
+      for (const tool of this.toolConfig.tools) {
+        if (typeof tool === 'string') {
+          toolsToLoad.push(tool);
+        } else {
+          toolsList.push(tool);
+        }
+      }
+      toolsList.push(
+        ...toolRegistry.getFunctionDeclarationsFiltered(toolsToLoad),
+      );
+    }
+    // Add local scope functions if outputs are expected.
+    if (this.outputConfig && this.outputConfig.outputs) {
+      toolsList.push(...this.getScopeLocalFuncDefs());
+    }
+
+    let currentMessages: Content[] = [
+      { role: 'user', parts: [{ text: 'Get Started!' }] },
+    ];
+
+    const startTime = Date.now();
+    let turnCounter = 0;
+    try {
+      while (true) {
+        // Check termination conditions.
+        if (
+          this.runConfig.max_turns &&
+          turnCounter >= this.runConfig.max_turns
+        ) {
+          this.output.terminate_reason = SubagentTerminateMode.MAX_TURNS;
+          break;
+        }
+        let durationMin = (Date.now() - startTime) / (1000 * 60);
+        if (durationMin >= this.runConfig.max_time_minutes) {
+          this.output.terminate_reason = SubagentTerminateMode.TIMEOUT;
+          break;
+        }
+
+        const promptId = `${this.runtimeContext.getSessionId()}#${this.subagentId}#${turnCounter++}`;
+        const messageParams = {
+          message: currentMessages[0]?.parts || [],
+          config: {
+            abortSignal: abortController.signal,
+            tools: [{ functionDeclarations: toolsList }],
+          },
+        };
+
+        const responseStream = await chat.sendMessageStream(
+          messageParams,
+          promptId,
+        );
+
+        const functionCalls: FunctionCall[] = [];
+        for await (const resp of responseStream) {
+          if (abortController.signal.aborted) return;
+          if (resp.functionCalls) functionCalls.push(...resp.functionCalls);
+        }
+
+        durationMin = (Date.now() - startTime) / (1000 * 60);
+        if (durationMin >= this.runConfig.max_time_minutes) {
+          this.output.terminate_reason = SubagentTerminateMode.TIMEOUT;
+          break;
+        }
+
+        if (functionCalls.length > 0) {
+          currentMessages = await this.processFunctionCalls(
+            functionCalls,
+            abortController,
+            promptId,
+          );
+        } else {
+          // Model stopped calling tools. Check if goal is met.
+          if (
+            !this.outputConfig ||
+            Object.keys(this.outputConfig.outputs).length === 0
+          ) {
+            this.output.terminate_reason = SubagentTerminateMode.GOAL;
+            break;
+          }
+
+          const remainingVars = Object.keys(this.outputConfig.outputs).filter(
+            (key) => !(key in this.output.emitted_vars),
+          );
+
+          if (remainingVars.length === 0) {
+            this.output.terminate_reason = SubagentTerminateMode.GOAL;
+            break;
+          }
+
+          const nudgeMessage = `You have stopped calling tools but have not emitted the following required variables: ${remainingVars.join(
+            ', ',
+          )}. Please use the 'self.emitvalue' tool to emit them now, or continue working if necessary.`;
+
+          console.debug(nudgeMessage);
+
+          currentMessages = [
+            {
+              role: 'user',
+              parts: [{ text: nudgeMessage }],
+            },
+          ];
+        }
+      }
+    } catch (error) {
+      console.error('Error during subagent execution:', error);
+      this.output.terminate_reason = SubagentTerminateMode.ERROR;
+      throw error;
+    }
+  }
+
+  /**
+   * Processes a list of function calls, executing each one and collecting their responses.
+   * This method iterates through the provided function calls, executes them using the
+   * `executeToolCall` function (or handles `self.emitvalue` internally), and aggregates
+   * their results. It also manages error reporting for failed tool executions.
+   * @param {FunctionCall[]} functionCalls - An array of `FunctionCall` objects to process.
+   * @param {ToolRegistry} toolRegistry - The tool registry to look up and execute tools.
+   * @param {AbortController} abortController - An `AbortController` to signal cancellation of tool executions.
+   * @returns {Promise<Content[]>} A promise that resolves to an array of `Content` parts representing the tool responses,
+   *          which are then used to update the chat history.
+   */
+  private async processFunctionCalls(
+    functionCalls: FunctionCall[],
+    abortController: AbortController,
+    promptId: string,
+  ): Promise<Content[]> {
+    const toolResponseParts: Part[] = [];
+
+    for (const functionCall of functionCalls) {
+      const callId = functionCall.id ?? `${functionCall.name}-${Date.now()}`;
+      const requestInfo: ToolCallRequestInfo = {
+        callId,
+        name: functionCall.name as string,
+        args: (functionCall.args ?? {}) as Record<string, unknown>,
+        isClientInitiated: true,
+        prompt_id: promptId,
+      };
+
+      let toolResponse;
+
+      // Handle scope-local tools first.
+      if (functionCall.name === 'self.emitvalue') {
+        const valName = String(requestInfo.args['emit_variable_name']);
+        const valVal = String(requestInfo.args['emit_variable_value']);
+        this.output.emitted_vars[valName] = valVal;
+
+        toolResponse = {
+          callId,
+          responseParts: `Emitted variable ${valName} successfully`,
+          resultDisplay: `Emitted variable ${valName} successfully`,
+          error: undefined,
+        };
+      } else {
+        toolResponse = await executeToolCall(
+          this.runtimeContext,
+          requestInfo,
+          abortController.signal,
+        );
+      }
+
+      if (toolResponse.error) {
+        console.error(
+          `Error executing tool ${functionCall.name}: ${toolResponse.resultDisplay || toolResponse.error.message}`,
+        );
+      }
+
+      if (toolResponse.responseParts) {
+        const parts = Array.isArray(toolResponse.responseParts)
+          ? toolResponse.responseParts
+          : [toolResponse.responseParts];
+        for (const part of parts) {
+          if (typeof part === 'string') {
+            toolResponseParts.push({ text: part });
+          } else if (part) {
+            toolResponseParts.push(part);
+          }
+        }
+      }
+    }
+    // If all tool calls failed, inform the model so it can re-evaluate.
+    if (functionCalls.length > 0 && toolResponseParts.length === 0) {
+      toolResponseParts.push({
+        text: 'All tool calls failed. Please analyze the errors and try an alternative approach.',
+      });
+    }
+
+    return [{ role: 'user', parts: toolResponseParts }];
+  }
+
+  private async createChatObject(context: ContextState) {
+    if (!this.promptConfig.systemPrompt && !this.promptConfig.initialMessages) {
+      throw new Error(
+        'PromptConfig must have either `systemPrompt` or `initialMessages` defined.',
+      );
+    }
+    if (this.promptConfig.systemPrompt && this.promptConfig.initialMessages) {
+      throw new Error(
+        'PromptConfig cannot have both `systemPrompt` and `initialMessages` defined.',
+      );
+    }
+
+    const envParts = await getEnvironmentContext(this.runtimeContext);
+    const envHistory: Content[] = [
+      { role: 'user', parts: envParts },
+      { role: 'model', parts: [{ text: 'Got it. Thanks for the context!' }] },
+    ];
+
+    const start_history = [
+      ...envHistory,
+      ...(this.promptConfig.initialMessages ?? []),
+    ];
+
+    const systemInstruction = this.promptConfig.systemPrompt
+      ? this.buildChatSystemPrompt(context)
+      : undefined;
+
+    try {
+      const generationConfig: GenerateContentConfig & {
+        systemInstruction?: string | Content;
+      } = {
+        temperature: this.modelConfig.temp,
+        topP: this.modelConfig.top_p,
+      };
+
+      if (systemInstruction) {
+        generationConfig.systemInstruction = systemInstruction;
+      }
+
+      const contentGenerator = await createContentGenerator(
+        this.runtimeContext.getContentGeneratorConfig(),
+        this.runtimeContext,
+        this.runtimeContext.getSessionId(),
+      );
+
+      this.runtimeContext.setModel(this.modelConfig.model);
+
+      return new GeminiChat(
+        this.runtimeContext,
+        contentGenerator,
+        generationConfig,
+        start_history,
+      );
+    } catch (error) {
+      await reportError(
+        error,
+        'Error initializing Gemini chat session.',
+        start_history,
+        'startChat',
+      );
+      // The calling function will handle the undefined return.
+      return undefined;
+    }
+  }
+
+  /**
+   * Returns an array of FunctionDeclaration objects for tools that are local to the subagent's scope.
+   * Currently, this includes the `self.emitvalue` tool for emitting variables.
+   * @returns An array of `FunctionDeclaration` objects.
+   */
+  private getScopeLocalFuncDefs() {
+    const emitValueTool: FunctionDeclaration = {
+      name: 'self.emitvalue',
+      description: `* This tool emits A SINGLE return value from this execution, such that it can be collected and presented to the calling function.
+        * You can only emit ONE VALUE each time you call this tool. You are expected to call this tool MULTIPLE TIMES if you have MULTIPLE OUTPUTS.`,
+      parameters: {
+        type: Type.OBJECT,
+        properties: {
+          emit_variable_name: {
+            description: 'This is the name of the variable to be returned.',
+            type: Type.STRING,
+          },
+          emit_variable_value: {
+            description:
+              'This is the _value_ to be returned for this variable.',
+            type: Type.STRING,
+          },
+        },
+        required: ['emit_variable_name', 'emit_variable_value'],
+      },
+    };
+
+    return [emitValueTool];
+  }
+
+  /**
+   * Builds the system prompt for the chat based on the provided configurations.
+   * It templates the base system prompt and appends instructions for emitting
+   * variables if an `OutputConfig` is provided.
+   * @param {ContextState} context - The context for templating.
+   * @returns {string} The complete system prompt.
+   */
+  private buildChatSystemPrompt(context: ContextState): string {
+    if (!this.promptConfig.systemPrompt) {
+      // This should ideally be caught in createChatObject, but serves as a safeguard.
+      return '';
+    }
+
+    let finalPrompt = templateString(this.promptConfig.systemPrompt, context);
+
+    // Add instructions for emitting variables if needed.
+    if (this.outputConfig && this.outputConfig.outputs) {
+      let outputInstructions =
+        '\n\nAfter you have achieved all other goals, you MUST emit the required output variables. For each expected output, make one final call to the `self.emitvalue` tool.';
+
+      for (const [key, value] of Object.entries(this.outputConfig.outputs)) {
+        outputInstructions += `\n* Use 'self.emitvalue' to emit the '${key}' key, with a value described as: '${value}'`;
+      }
+      finalPrompt += outputInstructions;
+    }
+
+    // Add general non-interactive instructions.
+    finalPrompt += `
+
+Important Rules:
+ * You are running in a non-interactive mode. You CANNOT ask the user for input or clarification. You must proceed with the information you have.
+ * Once you believe all goals have been met and all required outputs have been emitted, stop calling tools.`;
+
+    return finalPrompt;
+  }
+}

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

@@ -0,0 +1,32 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+type Model = string;
+type TokenCount = number;
+
+export const DEFAULT_TOKEN_LIMIT = 1_048_576;
+
+export function tokenLimit(model: Model): TokenCount {
+  // Add other models as they become relevant or if specified by config
+  // Pulled from https://ai.google.dev/gemini-api/docs/models
+  switch (model) {
+    case 'gemini-1.5-pro':
+      return 2_097_152;
+    case 'gemini-1.5-flash':
+    case 'gemini-2.5-pro-preview-05-06':
+    case 'gemini-2.5-pro-preview-06-05':
+    case 'gemini-2.5-pro':
+    case 'gemini-2.5-flash-preview-05-20':
+    case 'gemini-2.5-flash':
+    case 'gemini-2.5-flash-lite':
+    case 'gemini-2.0-flash':
+      return 1_048_576;
+    case 'gemini-2.0-flash-preview-image-generation':
+      return 32_000;
+    default:
+      return DEFAULT_TOKEN_LIMIT;
+  }
+}

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

@@ -0,0 +1,470 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import {
+  Turn,
+  GeminiEventType,
+  ServerGeminiToolCallRequestEvent,
+  ServerGeminiErrorEvent,
+} from './turn.js';
+import { GenerateContentResponse, Part, Content } from '@google/genai';
+import { reportError } from '../utils/errorReporting.js';
+import { GeminiChat } from './geminiChat.js';
+
+const mockSendMessageStream = vi.fn();
+const mockGetHistory = vi.fn();
+const mockMaybeIncludeSchemaDepthContext = vi.fn();
+
+vi.mock('@google/genai', async (importOriginal) => {
+  const actual = await importOriginal<typeof import('@google/genai')>();
+  const MockChat = vi.fn().mockImplementation(() => ({
+    sendMessageStream: mockSendMessageStream,
+    getHistory: mockGetHistory,
+    maybeIncludeSchemaDepthContext: mockMaybeIncludeSchemaDepthContext,
+  }));
+  return {
+    ...actual,
+    Chat: MockChat,
+  };
+});
+
+vi.mock('../utils/errorReporting', () => ({
+  reportError: vi.fn(),
+}));
+
+vi.mock('../utils/generateContentResponseUtilities', () => ({
+  getResponseText: (resp: GenerateContentResponse) =>
+    resp.candidates?.[0]?.content?.parts?.map((part) => part.text).join('') ||
+    undefined,
+}));
+
+describe('Turn', () => {
+  let turn: Turn;
+  // Define a type for the mocked Chat instance for clarity
+  type MockedChatInstance = {
+    sendMessageStream: typeof mockSendMessageStream;
+    getHistory: typeof mockGetHistory;
+    maybeIncludeSchemaDepthContext: typeof mockMaybeIncludeSchemaDepthContext;
+  };
+  let mockChatInstance: MockedChatInstance;
+
+  beforeEach(() => {
+    vi.resetAllMocks();
+    mockChatInstance = {
+      sendMessageStream: mockSendMessageStream,
+      getHistory: mockGetHistory,
+      maybeIncludeSchemaDepthContext: mockMaybeIncludeSchemaDepthContext,
+    };
+    turn = new Turn(mockChatInstance as unknown as GeminiChat, 'prompt-id-1');
+    mockGetHistory.mockReturnValue([]);
+    mockSendMessageStream.mockResolvedValue((async function* () {})());
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  describe('constructor', () => {
+    it('should initialize pendingToolCalls and debugResponses', () => {
+      expect(turn.pendingToolCalls).toEqual([]);
+      expect(turn.getDebugResponses()).toEqual([]);
+    });
+  });
+
+  describe('run', () => {
+    it('should yield content events for text parts', async () => {
+      const mockResponseStream = (async function* () {
+        yield {
+          candidates: [{ content: { parts: [{ text: 'Hello' }] } }],
+        } as unknown as GenerateContentResponse;
+        yield {
+          candidates: [{ content: { parts: [{ text: ' world' }] } }],
+        } as unknown as GenerateContentResponse;
+      })();
+      mockSendMessageStream.mockResolvedValue(mockResponseStream);
+
+      const events = [];
+      const reqParts: Part[] = [{ text: 'Hi' }];
+      for await (const event of turn.run(
+        reqParts,
+        new AbortController().signal,
+      )) {
+        events.push(event);
+      }
+
+      expect(mockSendMessageStream).toHaveBeenCalledWith(
+        {
+          message: reqParts,
+          config: { abortSignal: expect.any(AbortSignal) },
+        },
+        'prompt-id-1',
+      );
+
+      expect(events).toEqual([
+        { type: GeminiEventType.Content, value: 'Hello' },
+        { type: GeminiEventType.Content, value: ' world' },
+      ]);
+      expect(turn.getDebugResponses().length).toBe(2);
+    });
+
+    it('should yield tool_call_request events for function calls', async () => {
+      const mockResponseStream = (async function* () {
+        yield {
+          functionCalls: [
+            {
+              id: 'fc1',
+              name: 'tool1',
+              args: { arg1: 'val1' },
+              isClientInitiated: false,
+            },
+            { name: 'tool2', args: { arg2: 'val2' }, isClientInitiated: false }, // No ID
+          ],
+        } as unknown as GenerateContentResponse;
+      })();
+      mockSendMessageStream.mockResolvedValue(mockResponseStream);
+
+      const events = [];
+      const reqParts: Part[] = [{ text: 'Use tools' }];
+      for await (const event of turn.run(
+        reqParts,
+        new AbortController().signal,
+      )) {
+        events.push(event);
+      }
+
+      expect(events.length).toBe(2);
+      const event1 = events[0] as ServerGeminiToolCallRequestEvent;
+      expect(event1.type).toBe(GeminiEventType.ToolCallRequest);
+      expect(event1.value).toEqual(
+        expect.objectContaining({
+          callId: 'fc1',
+          name: 'tool1',
+          args: { arg1: 'val1' },
+          isClientInitiated: false,
+        }),
+      );
+      expect(turn.pendingToolCalls[0]).toEqual(event1.value);
+
+      const event2 = events[1] as ServerGeminiToolCallRequestEvent;
+      expect(event2.type).toBe(GeminiEventType.ToolCallRequest);
+      expect(event2.value).toEqual(
+        expect.objectContaining({
+          name: 'tool2',
+          args: { arg2: 'val2' },
+          isClientInitiated: false,
+        }),
+      );
+      expect(event2.value.callId).toEqual(
+        expect.stringMatching(/^tool2-\d{13}-\w{10,}$/),
+      );
+      expect(turn.pendingToolCalls[1]).toEqual(event2.value);
+      expect(turn.getDebugResponses().length).toBe(1);
+    });
+
+    it('should yield UserCancelled event if signal is aborted', async () => {
+      const abortController = new AbortController();
+      const mockResponseStream = (async function* () {
+        yield {
+          candidates: [{ content: { parts: [{ text: 'First part' }] } }],
+        } as unknown as GenerateContentResponse;
+        abortController.abort();
+        yield {
+          candidates: [
+            {
+              content: {
+                parts: [{ text: 'Second part - should not be processed' }],
+              },
+            },
+          ],
+        } as unknown as GenerateContentResponse;
+      })();
+      mockSendMessageStream.mockResolvedValue(mockResponseStream);
+
+      const events = [];
+      const reqParts: Part[] = [{ text: 'Test abort' }];
+      for await (const event of turn.run(reqParts, abortController.signal)) {
+        events.push(event);
+      }
+      expect(events).toEqual([
+        { type: GeminiEventType.Content, value: 'First part' },
+        { type: GeminiEventType.UserCancelled },
+      ]);
+      expect(turn.getDebugResponses().length).toBe(1);
+    });
+
+    it('should yield Error event and report if sendMessageStream throws', async () => {
+      const error = new Error('API Error');
+      mockSendMessageStream.mockRejectedValue(error);
+      const reqParts: Part[] = [{ text: 'Trigger error' }];
+      const historyContent: Content[] = [
+        { role: 'model', parts: [{ text: 'Previous history' }] },
+      ];
+      mockGetHistory.mockReturnValue(historyContent);
+      mockMaybeIncludeSchemaDepthContext.mockResolvedValue(undefined);
+      const events = [];
+      for await (const event of turn.run(
+        reqParts,
+        new AbortController().signal,
+      )) {
+        events.push(event);
+      }
+
+      expect(events.length).toBe(1);
+      const errorEvent = events[0] as ServerGeminiErrorEvent;
+      expect(errorEvent.type).toBe(GeminiEventType.Error);
+      expect(errorEvent.value).toEqual({
+        error: { message: 'API Error', status: undefined },
+      });
+      expect(turn.getDebugResponses().length).toBe(0);
+      expect(reportError).toHaveBeenCalledWith(
+        error,
+        'Error when talking to Gemini API',
+        [...historyContent, reqParts],
+        'Turn.run-sendMessageStream',
+      );
+    });
+
+    it('should handle function calls with undefined name or args', async () => {
+      const mockResponseStream = (async function* () {
+        yield {
+          functionCalls: [
+            { id: 'fc1', name: undefined, args: { arg1: 'val1' } },
+            { id: 'fc2', name: 'tool2', args: undefined },
+            { id: 'fc3', name: undefined, args: undefined },
+          ],
+        } as unknown as GenerateContentResponse;
+      })();
+      mockSendMessageStream.mockResolvedValue(mockResponseStream);
+      const events = [];
+      const reqParts: Part[] = [{ text: 'Test undefined tool parts' }];
+      for await (const event of turn.run(
+        reqParts,
+        new AbortController().signal,
+      )) {
+        events.push(event);
+      }
+
+      expect(events.length).toBe(3);
+      const event1 = events[0] as ServerGeminiToolCallRequestEvent;
+      expect(event1.type).toBe(GeminiEventType.ToolCallRequest);
+      expect(event1.value).toEqual(
+        expect.objectContaining({
+          callId: 'fc1',
+          name: 'undefined_tool_name',
+          args: { arg1: 'val1' },
+          isClientInitiated: false,
+        }),
+      );
+      expect(turn.pendingToolCalls[0]).toEqual(event1.value);
+
+      const event2 = events[1] as ServerGeminiToolCallRequestEvent;
+      expect(event2.type).toBe(GeminiEventType.ToolCallRequest);
+      expect(event2.value).toEqual(
+        expect.objectContaining({
+          callId: 'fc2',
+          name: 'tool2',
+          args: {},
+          isClientInitiated: false,
+        }),
+      );
+      expect(turn.pendingToolCalls[1]).toEqual(event2.value);
+
+      const event3 = events[2] as ServerGeminiToolCallRequestEvent;
+      expect(event3.type).toBe(GeminiEventType.ToolCallRequest);
+      expect(event3.value).toEqual(
+        expect.objectContaining({
+          callId: 'fc3',
+          name: 'undefined_tool_name',
+          args: {},
+          isClientInitiated: false,
+        }),
+      );
+      expect(turn.pendingToolCalls[2]).toEqual(event3.value);
+      expect(turn.getDebugResponses().length).toBe(1);
+    });
+
+    it('should yield finished event when response has finish reason', async () => {
+      const mockResponseStream = (async function* () {
+        yield {
+          candidates: [
+            {
+              content: { parts: [{ text: 'Partial response' }] },
+              finishReason: 'STOP',
+            },
+          ],
+        } as unknown as GenerateContentResponse;
+      })();
+      mockSendMessageStream.mockResolvedValue(mockResponseStream);
+
+      const events = [];
+      const reqParts: Part[] = [{ text: 'Test finish reason' }];
+      for await (const event of turn.run(
+        reqParts,
+        new AbortController().signal,
+      )) {
+        events.push(event);
+      }
+
+      expect(events).toEqual([
+        { type: GeminiEventType.Content, value: 'Partial response' },
+        { type: GeminiEventType.Finished, value: 'STOP' },
+      ]);
+    });
+
+    it('should yield finished event for MAX_TOKENS finish reason', async () => {
+      const mockResponseStream = (async function* () {
+        yield {
+          candidates: [
+            {
+              content: {
+                parts: [
+                  { text: 'This is a long response that was cut off...' },
+                ],
+              },
+              finishReason: 'MAX_TOKENS',
+            },
+          ],
+        } as unknown as GenerateContentResponse;
+      })();
+      mockSendMessageStream.mockResolvedValue(mockResponseStream);
+
+      const events = [];
+      const reqParts: Part[] = [{ text: 'Generate long text' }];
+      for await (const event of turn.run(
+        reqParts,
+        new AbortController().signal,
+      )) {
+        events.push(event);
+      }
+
+      expect(events).toEqual([
+        {
+          type: GeminiEventType.Content,
+          value: 'This is a long response that was cut off...',
+        },
+        { type: GeminiEventType.Finished, value: 'MAX_TOKENS' },
+      ]);
+    });
+
+    it('should yield finished event for SAFETY finish reason', async () => {
+      const mockResponseStream = (async function* () {
+        yield {
+          candidates: [
+            {
+              content: { parts: [{ text: 'Content blocked' }] },
+              finishReason: 'SAFETY',
+            },
+          ],
+        } as unknown as GenerateContentResponse;
+      })();
+      mockSendMessageStream.mockResolvedValue(mockResponseStream);
+
+      const events = [];
+      const reqParts: Part[] = [{ text: 'Test safety' }];
+      for await (const event of turn.run(
+        reqParts,
+        new AbortController().signal,
+      )) {
+        events.push(event);
+      }
+
+      expect(events).toEqual([
+        { type: GeminiEventType.Content, value: 'Content blocked' },
+        { type: GeminiEventType.Finished, value: 'SAFETY' },
+      ]);
+    });
+
+    it('should not yield finished event when there is no finish reason', async () => {
+      const mockResponseStream = (async function* () {
+        yield {
+          candidates: [
+            {
+              content: { parts: [{ text: 'Response without finish reason' }] },
+              // No finishReason property
+            },
+          ],
+        } as unknown as GenerateContentResponse;
+      })();
+      mockSendMessageStream.mockResolvedValue(mockResponseStream);
+
+      const events = [];
+      const reqParts: Part[] = [{ text: 'Test no finish reason' }];
+      for await (const event of turn.run(
+        reqParts,
+        new AbortController().signal,
+      )) {
+        events.push(event);
+      }
+
+      expect(events).toEqual([
+        {
+          type: GeminiEventType.Content,
+          value: 'Response without finish reason',
+        },
+      ]);
+      // No Finished event should be emitted
+    });
+
+    it('should handle multiple responses with different finish reasons', async () => {
+      const mockResponseStream = (async function* () {
+        yield {
+          candidates: [
+            {
+              content: { parts: [{ text: 'First part' }] },
+              // No finish reason on first response
+            },
+          ],
+        } as unknown as GenerateContentResponse;
+        yield {
+          candidates: [
+            {
+              content: { parts: [{ text: 'Second part' }] },
+              finishReason: 'OTHER',
+            },
+          ],
+        } as unknown as GenerateContentResponse;
+      })();
+      mockSendMessageStream.mockResolvedValue(mockResponseStream);
+
+      const events = [];
+      const reqParts: Part[] = [{ text: 'Test multiple responses' }];
+      for await (const event of turn.run(
+        reqParts,
+        new AbortController().signal,
+      )) {
+        events.push(event);
+      }
+
+      expect(events).toEqual([
+        { type: GeminiEventType.Content, value: 'First part' },
+        { type: GeminiEventType.Content, value: 'Second part' },
+        { type: GeminiEventType.Finished, value: 'OTHER' },
+      ]);
+    });
+  });
+
+  describe('getDebugResponses', () => {
+    it('should return collected debug responses', async () => {
+      const resp1 = {
+        candidates: [{ content: { parts: [{ text: 'Debug 1' }] } }],
+      } as unknown as GenerateContentResponse;
+      const resp2 = {
+        functionCalls: [{ name: 'debugTool' }],
+      } as unknown as GenerateContentResponse;
+      const mockResponseStream = (async function* () {
+        yield resp1;
+        yield resp2;
+      })();
+      mockSendMessageStream.mockResolvedValue(mockResponseStream);
+      const reqParts: Part[] = [{ text: 'Hi' }];
+      for await (const _ of turn.run(reqParts, new AbortController().signal)) {
+        // consume stream
+      }
+      expect(turn.getDebugResponses()).toEqual([resp1, resp2]);
+    });
+  });
+});

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

@@ -0,0 +1,323 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import {
+  PartListUnion,
+  GenerateContentResponse,
+  FunctionCall,
+  FunctionDeclaration,
+  FinishReason,
+} from '@google/genai';
+import {
+  ToolCallConfirmationDetails,
+  ToolResult,
+  ToolResultDisplay,
+} from '../tools/tools.js';
+import { ToolErrorType } from '../tools/tool-error.js';
+import { getResponseText } from '../utils/generateContentResponseUtilities.js';
+import { reportError } from '../utils/errorReporting.js';
+import {
+  getErrorMessage,
+  UnauthorizedError,
+  toFriendlyError,
+} from '../utils/errors.js';
+import { GeminiChat } from './geminiChat.js';
+
+// Define a structure for tools passed to the server
+export interface ServerTool {
+  name: string;
+  schema: FunctionDeclaration;
+  // The execute method signature might differ slightly or be wrapped
+  execute(
+    params: Record<string, unknown>,
+    signal?: AbortSignal,
+  ): Promise<ToolResult>;
+  shouldConfirmExecute(
+    params: Record<string, unknown>,
+    abortSignal: AbortSignal,
+  ): Promise<ToolCallConfirmationDetails | false>;
+}
+
+export enum GeminiEventType {
+  Content = 'content',
+  ToolCallRequest = 'tool_call_request',
+  ToolCallResponse = 'tool_call_response',
+  ToolCallConfirmation = 'tool_call_confirmation',
+  UserCancelled = 'user_cancelled',
+  Error = 'error',
+  ChatCompressed = 'chat_compressed',
+  Thought = 'thought',
+  MaxSessionTurns = 'max_session_turns',
+  SessionTokenLimitExceeded = 'session_token_limit_exceeded',
+  Finished = 'finished',
+  LoopDetected = 'loop_detected',
+}
+
+export interface StructuredError {
+  message: string;
+  status?: number;
+}
+
+export interface GeminiErrorEventValue {
+  error: StructuredError;
+}
+
+export interface SessionTokenLimitExceededValue {
+  currentTokens: number;
+  limit: number;
+  message: string;
+}
+
+export interface ToolCallRequestInfo {
+  callId: string;
+  name: string;
+  args: Record<string, unknown>;
+  isClientInitiated: boolean;
+  prompt_id: string;
+}
+
+export interface ToolCallResponseInfo {
+  callId: string;
+  responseParts: PartListUnion;
+  resultDisplay: ToolResultDisplay | undefined;
+  error: Error | undefined;
+  errorType: ToolErrorType | undefined;
+}
+
+export interface ServerToolCallConfirmationDetails {
+  request: ToolCallRequestInfo;
+  details: ToolCallConfirmationDetails;
+}
+
+export type ThoughtSummary = {
+  subject: string;
+  description: string;
+};
+
+export type ServerGeminiContentEvent = {
+  type: GeminiEventType.Content;
+  value: string;
+};
+
+export type ServerGeminiThoughtEvent = {
+  type: GeminiEventType.Thought;
+  value: ThoughtSummary;
+};
+
+export type ServerGeminiToolCallRequestEvent = {
+  type: GeminiEventType.ToolCallRequest;
+  value: ToolCallRequestInfo;
+};
+
+export type ServerGeminiToolCallResponseEvent = {
+  type: GeminiEventType.ToolCallResponse;
+  value: ToolCallResponseInfo;
+};
+
+export type ServerGeminiToolCallConfirmationEvent = {
+  type: GeminiEventType.ToolCallConfirmation;
+  value: ServerToolCallConfirmationDetails;
+};
+
+export type ServerGeminiUserCancelledEvent = {
+  type: GeminiEventType.UserCancelled;
+};
+
+export type ServerGeminiErrorEvent = {
+  type: GeminiEventType.Error;
+  value: GeminiErrorEventValue;
+};
+
+export interface ChatCompressionInfo {
+  originalTokenCount: number;
+  newTokenCount: number;
+}
+
+export type ServerGeminiChatCompressedEvent = {
+  type: GeminiEventType.ChatCompressed;
+  value: ChatCompressionInfo | null;
+};
+
+export type ServerGeminiMaxSessionTurnsEvent = {
+  type: GeminiEventType.MaxSessionTurns;
+};
+
+export type ServerGeminiSessionTokenLimitExceededEvent = {
+  type: GeminiEventType.SessionTokenLimitExceeded;
+  value: SessionTokenLimitExceededValue;
+};
+
+export type ServerGeminiFinishedEvent = {
+  type: GeminiEventType.Finished;
+  value: FinishReason;
+};
+
+export type ServerGeminiLoopDetectedEvent = {
+  type: GeminiEventType.LoopDetected;
+};
+
+// The original union type, now composed of the individual types
+export type ServerGeminiStreamEvent =
+  | ServerGeminiContentEvent
+  | ServerGeminiToolCallRequestEvent
+  | ServerGeminiToolCallResponseEvent
+  | ServerGeminiToolCallConfirmationEvent
+  | ServerGeminiUserCancelledEvent
+  | ServerGeminiErrorEvent
+  | ServerGeminiChatCompressedEvent
+  | ServerGeminiThoughtEvent
+  | ServerGeminiMaxSessionTurnsEvent
+  | ServerGeminiSessionTokenLimitExceededEvent
+  | ServerGeminiFinishedEvent
+  | ServerGeminiLoopDetectedEvent;
+
+// A turn manages the agentic loop turn within the server context.
+export class Turn {
+  readonly pendingToolCalls: ToolCallRequestInfo[];
+  private debugResponses: GenerateContentResponse[];
+  finishReason: FinishReason | undefined;
+
+  constructor(
+    private readonly chat: GeminiChat,
+    private readonly prompt_id: string,
+  ) {
+    this.pendingToolCalls = [];
+    this.debugResponses = [];
+    this.finishReason = undefined;
+  }
+  // The run method yields simpler events suitable for server logic
+  async *run(
+    req: PartListUnion,
+    signal: AbortSignal,
+  ): AsyncGenerator<ServerGeminiStreamEvent> {
+    try {
+      const responseStream = await this.chat.sendMessageStream(
+        {
+          message: req,
+          config: {
+            abortSignal: signal,
+          },
+        },
+        this.prompt_id,
+      );
+
+      for await (const resp of responseStream) {
+        if (signal?.aborted) {
+          yield { type: GeminiEventType.UserCancelled };
+          // Do not add resp to debugResponses if aborted before processing
+          return;
+        }
+        this.debugResponses.push(resp);
+
+        const thoughtPart = resp.candidates?.[0]?.content?.parts?.[0];
+        if (thoughtPart?.thought) {
+          // Thought always has a bold "subject" part enclosed in double asterisks
+          // (e.g., **Subject**). The rest of the string is considered the description.
+          const rawText = thoughtPart.text ?? '';
+          const subjectStringMatches = rawText.match(/\*\*(.*?)\*\*/s);
+          const subject = subjectStringMatches
+            ? subjectStringMatches[1].trim()
+            : '';
+          const description = rawText.replace(/\*\*(.*?)\*\*/s, '').trim();
+          const thought: ThoughtSummary = {
+            subject,
+            description,
+          };
+
+          yield {
+            type: GeminiEventType.Thought,
+            value: thought,
+          };
+          continue;
+        }
+
+        const text = getResponseText(resp);
+        if (text) {
+          yield { type: GeminiEventType.Content, value: text };
+        }
+
+        // Handle function calls (requesting tool execution)
+        const functionCalls = resp.functionCalls ?? [];
+        for (const fnCall of functionCalls) {
+          const event = this.handlePendingFunctionCall(fnCall);
+          if (event) {
+            yield event;
+          }
+        }
+
+        // Check if response was truncated or stopped for various reasons
+        const finishReason = resp.candidates?.[0]?.finishReason;
+
+        if (finishReason) {
+          this.finishReason = finishReason;
+          yield {
+            type: GeminiEventType.Finished,
+            value: finishReason as FinishReason,
+          };
+        }
+      }
+    } catch (e) {
+      const error = toFriendlyError(e);
+      if (error instanceof UnauthorizedError) {
+        throw error;
+      }
+      if (signal.aborted) {
+        yield { type: GeminiEventType.UserCancelled };
+        // Regular cancellation error, fail gracefully.
+        return;
+      }
+
+      const contextForReport = [...this.chat.getHistory(/*curated*/ true), req];
+      await reportError(
+        error,
+        'Error when talking to Gemini API',
+        contextForReport,
+        'Turn.run-sendMessageStream',
+      );
+      const status =
+        typeof error === 'object' &&
+        error !== null &&
+        'status' in error &&
+        typeof (error as { status: unknown }).status === 'number'
+          ? (error as { status: number }).status
+          : undefined;
+      const structuredError: StructuredError = {
+        message: getErrorMessage(error),
+        status,
+      };
+      await this.chat.maybeIncludeSchemaDepthContext(structuredError);
+      yield { type: GeminiEventType.Error, value: { error: structuredError } };
+      return;
+    }
+  }
+
+  private handlePendingFunctionCall(
+    fnCall: FunctionCall,
+  ): ServerGeminiStreamEvent | null {
+    const callId =
+      fnCall.id ??
+      `${fnCall.name}-${Date.now()}-${Math.random().toString(16).slice(2)}`;
+    const name = fnCall.name || 'undefined_tool_name';
+    const args = (fnCall.args || {}) as Record<string, unknown>;
+
+    const toolCallRequest: ToolCallRequestInfo = {
+      callId,
+      name,
+      args,
+      isClientInitiated: false,
+      prompt_id: this.prompt_id,
+    };
+
+    this.pendingToolCalls.push(toolCallRequest);
+
+    // Yield a request for the tool call, not the pending/confirming status
+    return { type: GeminiEventType.ToolCallRequest, value: toolCallRequest };
+  }
+
+  getDebugResponses(): GenerateContentResponse[] {
+    return this.debugResponses;
+  }
+}

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

@@ -0,0 +1,7 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+export const QWEN_CODE_COMPANION_EXTENSION_NAME = 'Qwen Code Companion';

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

@@ -0,0 +1,92 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { describe, it, expect, afterEach, vi } from 'vitest';
+import { detectIde, DetectedIde } from './detect-ide.js';
+
+describe('detectIde', () => {
+  afterEach(() => {
+    vi.unstubAllEnvs();
+  });
+
+  it.each([
+    {
+      env: {},
+      expected: DetectedIde.VSCode,
+    },
+    {
+      env: { __COG_BASHRC_SOURCED: '1' },
+      expected: DetectedIde.Devin,
+    },
+    {
+      env: { REPLIT_USER: 'test' },
+      expected: DetectedIde.Replit,
+    },
+    {
+      env: { CURSOR_TRACE_ID: 'test' },
+      expected: DetectedIde.Cursor,
+    },
+    {
+      env: { CODESPACES: 'true' },
+      expected: DetectedIde.Codespaces,
+    },
+    {
+      env: { EDITOR_IN_CLOUD_SHELL: 'true' },
+      expected: DetectedIde.CloudShell,
+    },
+    {
+      env: { CLOUD_SHELL: 'true' },
+      expected: DetectedIde.CloudShell,
+    },
+    {
+      env: { TERM_PRODUCT: 'Trae' },
+      expected: DetectedIde.Trae,
+    },
+    {
+      env: { FIREBASE_DEPLOY_AGENT: 'true' },
+      expected: DetectedIde.FirebaseStudio,
+    },
+    {
+      env: { MONOSPACE_ENV: 'true' },
+      expected: DetectedIde.FirebaseStudio,
+    },
+  ])('detects the IDE for $expected', ({ env, expected }) => {
+    // Clear all environment variables first
+    vi.unstubAllEnvs();
+
+    // Set TERM_PROGRAM to vscode (required for all IDE detection)
+    vi.stubEnv('TERM_PROGRAM', 'vscode');
+
+    // Explicitly stub all environment variables that detectIde() checks to undefined
+    // This ensures no real environment variables interfere with the tests
+    vi.stubEnv('__COG_BASHRC_SOURCED', undefined);
+    vi.stubEnv('REPLIT_USER', undefined);
+    vi.stubEnv('CURSOR_TRACE_ID', undefined);
+    vi.stubEnv('CODESPACES', undefined);
+    vi.stubEnv('EDITOR_IN_CLOUD_SHELL', undefined);
+    vi.stubEnv('CLOUD_SHELL', undefined);
+    vi.stubEnv('TERM_PRODUCT', undefined);
+    vi.stubEnv('FIREBASE_DEPLOY_AGENT', undefined);
+    vi.stubEnv('MONOSPACE_ENV', undefined);
+
+    // Set only the specific environment variables for this test case
+    for (const [key, value] of Object.entries(env)) {
+      vi.stubEnv(key, value);
+    }
+
+    expect(detectIde()).toBe(expected);
+  });
+
+  it('returns undefined for non-vscode', () => {
+    // Clear all environment variables first
+    vi.unstubAllEnvs();
+
+    // Set TERM_PROGRAM to something other than vscode
+    vi.stubEnv('TERM_PROGRAM', 'definitely-not-vscode');
+
+    expect(detectIde()).toBeUndefined();
+  });
+});

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

@@ -0,0 +1,91 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+export enum DetectedIde {
+  Devin = 'devin',
+  Replit = 'replit',
+  VSCode = 'vscode',
+  Cursor = 'cursor',
+  CloudShell = 'cloudshell',
+  Codespaces = 'codespaces',
+  FirebaseStudio = 'firebasestudio',
+  Trae = 'trae',
+}
+
+export interface IdeInfo {
+  displayName: string;
+}
+
+export function getIdeInfo(ide: DetectedIde): IdeInfo {
+  switch (ide) {
+    case DetectedIde.Devin:
+      return {
+        displayName: 'Devin',
+      };
+    case DetectedIde.Replit:
+      return {
+        displayName: 'Replit',
+      };
+    case DetectedIde.VSCode:
+      return {
+        displayName: 'VS Code',
+      };
+    case DetectedIde.Cursor:
+      return {
+        displayName: 'Cursor',
+      };
+    case DetectedIde.CloudShell:
+      return {
+        displayName: 'Cloud Shell',
+      };
+    case DetectedIde.Codespaces:
+      return {
+        displayName: 'GitHub Codespaces',
+      };
+    case DetectedIde.FirebaseStudio:
+      return {
+        displayName: 'Firebase Studio',
+      };
+    case DetectedIde.Trae:
+      return {
+        displayName: 'Trae',
+      };
+    default: {
+      // This ensures that if a new IDE is added to the enum, we get a compile-time error.
+      const exhaustiveCheck: never = ide;
+      return exhaustiveCheck;
+    }
+  }
+}
+
+export function detectIde(): DetectedIde | undefined {
+  // Only VSCode-based integrations are currently supported.
+  if (process.env['TERM_PROGRAM'] !== 'vscode') {
+    return undefined;
+  }
+  if (process.env['__COG_BASHRC_SOURCED']) {
+    return DetectedIde.Devin;
+  }
+  if (process.env['REPLIT_USER']) {
+    return DetectedIde.Replit;
+  }
+  if (process.env['CURSOR_TRACE_ID']) {
+    return DetectedIde.Cursor;
+  }
+  if (process.env['CODESPACES']) {
+    return DetectedIde.Codespaces;
+  }
+  if (process.env['EDITOR_IN_CLOUD_SHELL'] || process.env['CLOUD_SHELL']) {
+    return DetectedIde.CloudShell;
+  }
+  if (process.env['TERM_PRODUCT'] === 'Trae') {
+    return DetectedIde.Trae;
+  }
+  if (process.env['FIREBASE_DEPLOY_AGENT'] || process.env['MONOSPACE_ENV']) {
+    return DetectedIde.FirebaseStudio;
+  }
+  return DetectedIde.VSCode;
+}