Add files using upload-large-folder tool

projects/ui/qwen-code/packages/core/src/tools/shell.ts

@@ -0,0 +1,477 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import crypto from 'crypto';
+import { Config } from '../config/config.js';
+import {
+  BaseDeclarativeTool,
+  BaseToolInvocation,
+  ToolInvocation,
+  ToolResult,
+  ToolCallConfirmationDetails,
+  ToolExecuteConfirmationDetails,
+  ToolConfirmationOutcome,
+  Kind,
+} from './tools.js';
+import { getErrorMessage } from '../utils/errors.js';
+import { summarizeToolOutput } from '../utils/summarizer.js';
+import {
+  ShellExecutionService,
+  ShellOutputEvent,
+} from '../services/shellExecutionService.js';
+import { formatMemoryUsage } from '../utils/formatters.js';
+import {
+  getCommandRoots,
+  isCommandAllowed,
+  stripShellWrapper,
+} from '../utils/shell-utils.js';
+
+export const OUTPUT_UPDATE_INTERVAL_MS = 1000;
+
+export interface ShellToolParams {
+  command: string;
+  is_background: boolean;
+  description?: string;
+  directory?: string;
+}
+
+class ShellToolInvocation extends BaseToolInvocation<
+  ShellToolParams,
+  ToolResult
+> {
+  constructor(
+    private readonly config: Config,
+    params: ShellToolParams,
+    private readonly allowlist: Set<string>,
+  ) {
+    super(params);
+  }
+
+  getDescription(): string {
+    let description = `${this.params.command}`;
+    // append optional [in directory]
+    // note description is needed even if validation fails due to absolute path
+    if (this.params.directory) {
+      description += ` [in ${this.params.directory}]`;
+    }
+    // append background indicator
+    if (this.params.is_background) {
+      description += ` [background]`;
+    }
+    // append optional (description), replacing any line breaks with spaces
+    if (this.params.description) {
+      description += ` (${this.params.description.replace(/\n/g, ' ')})`;
+    }
+    return description;
+  }
+
+  override async shouldConfirmExecute(
+    _abortSignal: AbortSignal,
+  ): Promise<ToolCallConfirmationDetails | false> {
+    const command = stripShellWrapper(this.params.command);
+    const rootCommands = [...new Set(getCommandRoots(command))];
+    const commandsToConfirm = rootCommands.filter(
+      (command) => !this.allowlist.has(command),
+    );
+
+    if (commandsToConfirm.length === 0) {
+      return false; // already approved and whitelisted
+    }
+
+    const confirmationDetails: ToolExecuteConfirmationDetails = {
+      type: 'exec',
+      title: 'Confirm Shell Command',
+      command: this.params.command,
+      rootCommand: commandsToConfirm.join(', '),
+      onConfirm: async (outcome: ToolConfirmationOutcome) => {
+        if (outcome === ToolConfirmationOutcome.ProceedAlways) {
+          commandsToConfirm.forEach((command) => this.allowlist.add(command));
+        }
+      },
+    };
+    return confirmationDetails;
+  }
+
+  async execute(
+    signal: AbortSignal,
+    updateOutput?: (output: string) => void,
+    terminalColumns?: number,
+    terminalRows?: number,
+  ): Promise<ToolResult> {
+    const strippedCommand = stripShellWrapper(this.params.command);
+
+    if (signal.aborted) {
+      return {
+        llmContent: 'Command was cancelled by user before it could start.',
+        returnDisplay: 'Command cancelled by user.',
+      };
+    }
+
+    const isWindows = os.platform() === 'win32';
+    const tempFileName = `shell_pgrep_${crypto
+      .randomBytes(6)
+      .toString('hex')}.tmp`;
+    const tempFilePath = path.join(os.tmpdir(), tempFileName);
+
+    try {
+      // Add co-author to git commit commands
+      const processedCommand = this.addCoAuthorToGitCommit(strippedCommand);
+
+      const shouldRunInBackground = this.params.is_background;
+      let finalCommand = processedCommand;
+
+      // If explicitly marked as background and doesn't already end with &, add it
+      if (shouldRunInBackground && !finalCommand.trim().endsWith('&')) {
+        finalCommand = finalCommand.trim() + ' &';
+      }
+
+      // pgrep is not available on Windows, so we can't get background PIDs
+      const commandToExecute = isWindows
+        ? finalCommand
+        : (() => {
+            // wrap command to append subprocess pids (via pgrep) to temporary file
+            let command = finalCommand.trim();
+            if (!command.endsWith('&')) command += ';';
+            return `{ ${command} }; __code=$?; pgrep -g 0 >${tempFilePath} 2>&1; exit $__code;`;
+          })();
+
+      const cwd = path.resolve(
+        this.config.getTargetDir(),
+        this.params.directory || '',
+      );
+
+      let cumulativeOutput = '';
+      let lastUpdateTime = Date.now();
+      let isBinaryStream = false;
+
+      const { result: resultPromise } = await ShellExecutionService.execute(
+        commandToExecute,
+        cwd,
+        (event: ShellOutputEvent) => {
+          if (!updateOutput) {
+            return;
+          }
+
+          let currentDisplayOutput = '';
+          let shouldUpdate = false;
+
+          switch (event.type) {
+            case 'data':
+              if (isBinaryStream) break;
+              cumulativeOutput = event.chunk;
+              currentDisplayOutput = cumulativeOutput;
+              if (Date.now() - lastUpdateTime > OUTPUT_UPDATE_INTERVAL_MS) {
+                shouldUpdate = true;
+              }
+              break;
+            case 'binary_detected':
+              isBinaryStream = true;
+              currentDisplayOutput =
+                '[Binary output detected. Halting stream...]';
+              shouldUpdate = true;
+              break;
+            case 'binary_progress':
+              isBinaryStream = true;
+              currentDisplayOutput = `[Receiving binary output... ${formatMemoryUsage(
+                event.bytesReceived,
+              )} received]`;
+              if (Date.now() - lastUpdateTime > OUTPUT_UPDATE_INTERVAL_MS) {
+                shouldUpdate = true;
+              }
+              break;
+            default: {
+              throw new Error('An unhandled ShellOutputEvent was found.');
+            }
+          }
+
+          if (shouldUpdate) {
+            updateOutput(currentDisplayOutput);
+            lastUpdateTime = Date.now();
+          }
+        },
+        signal,
+        this.config.getShouldUseNodePtyShell(),
+        terminalColumns,
+        terminalRows,
+      );
+
+      const result = await resultPromise;
+
+      const backgroundPIDs: number[] = [];
+      if (os.platform() !== 'win32') {
+        if (fs.existsSync(tempFilePath)) {
+          const pgrepLines = fs
+            .readFileSync(tempFilePath, 'utf8')
+            .split('\n')
+            .filter(Boolean);
+          for (const line of pgrepLines) {
+            if (!/^\d+$/.test(line)) {
+              console.error(`pgrep: ${line}`);
+            }
+            const pid = Number(line);
+            if (pid !== result.pid) {
+              backgroundPIDs.push(pid);
+            }
+          }
+        } else {
+          if (!signal.aborted) {
+            console.error('missing pgrep output');
+          }
+        }
+      }
+
+      let llmContent = '';
+      if (result.aborted) {
+        llmContent = 'Command was cancelled by user before it could complete.';
+        if (result.output.trim()) {
+          llmContent += ` Below is the output before it was cancelled:\n${result.output}`;
+        } else {
+          llmContent += ' There was no output before it was cancelled.';
+        }
+      } else {
+        // Create a formatted error string for display, replacing the wrapper command
+        // with the user-facing command.
+        const finalError = result.error
+          ? result.error.message.replace(commandToExecute, this.params.command)
+          : '(none)';
+
+        llmContent = [
+          `Command: ${this.params.command}`,
+          `Directory: ${this.params.directory || '(root)'}`,
+          `Output: ${result.output || '(empty)'}`,
+          `Error: ${finalError}`, // Use the cleaned error string.
+          `Exit Code: ${result.exitCode ?? '(none)'}`,
+          `Signal: ${result.signal ?? '(none)'}`,
+          `Background PIDs: ${
+            backgroundPIDs.length ? backgroundPIDs.join(', ') : '(none)'
+          }`,
+          `Process Group PGID: ${result.pid ?? '(none)'}`,
+        ].join('\n');
+      }
+
+      let returnDisplayMessage = '';
+      if (this.config.getDebugMode()) {
+        returnDisplayMessage = llmContent;
+      } else {
+        if (result.output.trim()) {
+          returnDisplayMessage = result.output;
+        } else {
+          if (result.aborted) {
+            returnDisplayMessage = 'Command cancelled by user.';
+          } else if (result.signal) {
+            returnDisplayMessage = `Command terminated by signal: ${result.signal}`;
+          } else if (result.error) {
+            returnDisplayMessage = `Command failed: ${getErrorMessage(
+              result.error,
+            )}`;
+          } else if (result.exitCode !== null && result.exitCode !== 0) {
+            returnDisplayMessage = `Command exited with code: ${result.exitCode}`;
+          }
+          // If output is empty and command succeeded (code 0, no error/signal/abort),
+          // returnDisplayMessage will remain empty, which is fine.
+        }
+      }
+
+      const summarizeConfig = this.config.getSummarizeToolOutputConfig();
+      if (summarizeConfig && summarizeConfig[ShellTool.Name]) {
+        const summary = await summarizeToolOutput(
+          llmContent,
+          this.config.getGeminiClient(),
+          signal,
+          summarizeConfig[ShellTool.Name].tokenBudget,
+        );
+        return {
+          llmContent: summary,
+          returnDisplay: returnDisplayMessage,
+        };
+      }
+
+      return {
+        llmContent,
+        returnDisplay: returnDisplayMessage,
+      };
+    } finally {
+      if (fs.existsSync(tempFilePath)) {
+        fs.unlinkSync(tempFilePath);
+      }
+    }
+  }
+
+  private addCoAuthorToGitCommit(command: string): string {
+    // Check if co-author feature is enabled
+    const gitCoAuthorSettings = this.config.getGitCoAuthor();
+    if (!gitCoAuthorSettings.enabled) {
+      return command;
+    }
+
+    // Check if this is a git commit command
+    const gitCommitPattern = /^git\s+commit/;
+    if (!gitCommitPattern.test(command.trim())) {
+      return command;
+    }
+
+    // Define the co-author line using configuration
+    const coAuthor = `
+
+Co-authored-by: ${gitCoAuthorSettings.name} <${gitCoAuthorSettings.email}>`;
+
+    // Handle different git commit patterns
+    // Match -m "message" or -m 'message'
+    const messagePattern = /(-m\s+)(['"])((?:\\.|[^\\])*?)(\2)/;
+    const match = command.match(messagePattern);
+
+    if (match) {
+      const [fullMatch, prefix, quote, existingMessage, closingQuote] = match;
+      const newMessage = existingMessage + coAuthor;
+      const replacement = prefix + quote + newMessage + closingQuote;
+
+      return command.replace(fullMatch, replacement);
+    }
+
+    // If no -m flag found, the command might open an editor
+    // In this case, we can't easily modify it, so return as-is
+    return command;
+  }
+}
+
+function getShellToolDescription(): string {
+  const platform = os.platform();
+  const toolDescription = `
+    ${platform === 'win32' ? 'This tool executes a given shell command as `cmd.exe /c <command>`.' : 'This tool executes a given shell command as `bash -c <command>`. '}
+
+      **Background vs Foreground Execution:**
+      You should decide whether commands should run in background or foreground based on their nature:
+      
+      **Use background execution (is_background: true) for:**
+      - Long-running development servers: \`npm run start\`, \`npm run dev\`, \`yarn dev\`, \`bun run start\`
+      - Build watchers: \`npm run watch\`, \`webpack --watch\`
+      - Database servers: \`mongod\`, \`mysql\`, \`redis-server\`
+      - Web servers: \`python -m http.server\`, \`php -S localhost:8000\`
+      - Any command expected to run indefinitely until manually stopped
+      
+      **Use foreground execution (is_background: false) for:**
+      - One-time commands: \`ls\`, \`cat\`, \`grep\`
+      - Build commands: \`npm run build\`, \`make\`
+      - Installation commands: \`npm install\`, \`pip install\`
+      - Git operations: \`git commit\`, \`git push\`
+      - Test runs: \`npm test\`, \`pytest\`
+      
+      ${platform === 'win32' ? '' : 'Command is executed as a subprocess that leads its own process group. Command process group can be terminated as `kill -- -PGID` or signaled as `kill -s SIGNAL -- -PGID`.'}
+
+      The following information is returned:
+
+      Command: Executed command.
+      Directory: Directory (relative to project root) where command was executed, or \`(root)\`.
+      Stdout: Output on stdout stream. Can be \`(empty)\` or partial on error and for any unwaited background processes.
+      Stderr: Output on stderr stream. Can be \`(empty)\` or partial on error and for any unwaited background processes.
+      Error: Error or \`(none)\` if no error was reported for the subprocess.
+      Exit Code: Exit code or \`(none)\` if terminated by signal.
+      Signal: Signal number or \`(none)\` if no signal was received.
+      Background PIDs: List of background processes started or \`(none)\`.
+      Process Group PGID: Process group started or \`(none)\``;
+
+  return toolDescription;
+}
+
+function getCommandDescription(): string {
+  if (os.platform() === 'win32') {
+    return 'Exact command to execute as `cmd.exe /c <command>`';
+  } else {
+    return 'Exact bash command to execute as `bash -c <command>`';
+  }
+}
+
+export class ShellTool extends BaseDeclarativeTool<
+  ShellToolParams,
+  ToolResult
+> {
+  static Name: string = 'run_shell_command';
+  private allowlist: Set<string> = new Set();
+
+  constructor(private readonly config: Config) {
+    super(
+      ShellTool.Name,
+      'Shell',
+      getShellToolDescription(),
+      Kind.Execute,
+      {
+        type: 'object',
+        properties: {
+          command: {
+            type: 'string',
+            description: getCommandDescription(),
+          },
+          is_background: {
+            type: 'boolean',
+            description:
+              'Whether to run the command in background. Default is false. Set to true for long-running processes like development servers, watchers, or daemons that should continue running without blocking further commands.',
+          },
+          description: {
+            type: 'string',
+            description:
+              'Brief description of the command for the user. Be specific and concise. Ideally a single sentence. Can be up to 3 sentences for clarity. No line breaks.',
+          },
+          directory: {
+            type: 'string',
+            description:
+              '(OPTIONAL) Directory to run the command in, if not the project root directory. Must be relative to the project root directory and must already exist.',
+          },
+        },
+        required: ['command', 'is_background'],
+      },
+      false, // output is not markdown
+      true, // output can be updated
+    );
+  }
+
+  protected override validateToolParamValues(
+    params: ShellToolParams,
+  ): string | null {
+    const commandCheck = isCommandAllowed(params.command, this.config);
+    if (!commandCheck.allowed) {
+      if (!commandCheck.reason) {
+        console.error(
+          'Unexpected: isCommandAllowed returned false without a reason',
+        );
+        return `Command is not allowed: ${params.command}`;
+      }
+      return commandCheck.reason;
+    }
+    if (!params.command.trim()) {
+      return 'Command cannot be empty.';
+    }
+    if (getCommandRoots(params.command).length === 0) {
+      return 'Could not identify command root to obtain permission from user.';
+    }
+    if (params.directory) {
+      if (path.isAbsolute(params.directory)) {
+        return 'Directory cannot be absolute. Please refer to workspace directories by their name.';
+      }
+      const workspaceDirs = this.config.getWorkspaceContext().getDirectories();
+      const matchingDirs = workspaceDirs.filter(
+        (dir) => path.basename(dir) === params.directory,
+      );
+
+      if (matchingDirs.length === 0) {
+        return `Directory '${params.directory}' is not a registered workspace directory.`;
+      }
+
+      if (matchingDirs.length > 1) {
+        return `Directory name '${params.directory}' is ambiguous as it matches multiple workspace directories.`;
+      }
+    }
+    return null;
+  }
+
+  protected createInvocation(
+    params: ShellToolParams,
+  ): ToolInvocation<ShellToolParams, ToolResult> {
+    return new ShellToolInvocation(this.config, params, this.allowlist);
+  }
+}

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

@@ -0,0 +1,287 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { TodoWriteTool, TodoWriteParams, TodoItem } from './todoWrite.js';
+import * as fs from 'fs/promises';
+import * as fsSync from 'fs';
+import { Config } from '../config/config.js';
+
+// Mock fs modules
+vi.mock('fs/promises');
+vi.mock('fs');
+
+const mockFs = vi.mocked(fs);
+const mockFsSync = vi.mocked(fsSync);
+
+describe('TodoWriteTool', () => {
+  let tool: TodoWriteTool;
+  let mockAbortSignal: AbortSignal;
+  let mockConfig: Config;
+
+  beforeEach(() => {
+    mockConfig = {
+      getSessionId: () => 'test-session-123',
+    } as Config;
+    tool = new TodoWriteTool(mockConfig);
+    mockAbortSignal = new AbortController().signal;
+    vi.clearAllMocks();
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  describe('validateToolParams', () => {
+    it('should validate correct parameters', () => {
+      const params: TodoWriteParams = {
+        todos: [
+          { id: '1', content: 'Task 1', status: 'pending' },
+          { id: '2', content: 'Task 2', status: 'in_progress' },
+        ],
+      };
+
+      const result = tool.validateToolParams(params);
+      expect(result).toBeNull();
+    });
+
+    it('should accept empty todos array', () => {
+      const params: TodoWriteParams = {
+        todos: [],
+      };
+
+      const result = tool.validateToolParams(params);
+      expect(result).toBeNull();
+    });
+
+    it('should accept single todo', () => {
+      const params: TodoWriteParams = {
+        todos: [{ id: '1', content: 'Task 1', status: 'pending' }],
+      };
+
+      const result = tool.validateToolParams(params);
+      expect(result).toBeNull();
+    });
+
+    it('should reject todos with empty content', () => {
+      const params: TodoWriteParams = {
+        todos: [
+          { id: '1', content: '', status: 'pending' },
+          { id: '2', content: 'Task 2', status: 'pending' },
+        ],
+      };
+
+      const result = tool.validateToolParams(params);
+      expect(result).toContain(
+        'Each todo must have a non-empty "content" string',
+      );
+    });
+
+    it('should reject todos with empty id', () => {
+      const params: TodoWriteParams = {
+        todos: [
+          { id: '', content: 'Task 1', status: 'pending' },
+          { id: '2', content: 'Task 2', status: 'pending' },
+        ],
+      };
+
+      const result = tool.validateToolParams(params);
+      expect(result).toContain('non-empty "id" string');
+    });
+
+    it('should reject todos with invalid status', () => {
+      const params: TodoWriteParams = {
+        todos: [
+          {
+            id: '1',
+            content: 'Task 1',
+            status: 'invalid' as TodoItem['status'],
+          },
+          { id: '2', content: 'Task 2', status: 'pending' },
+        ],
+      };
+
+      const result = tool.validateToolParams(params);
+      expect(result).toContain(
+        'Each todo must have a valid "status" (pending, in_progress, completed)',
+      );
+    });
+
+    it('should reject todos with duplicate IDs', () => {
+      const params: TodoWriteParams = {
+        todos: [
+          { id: '1', content: 'Task 1', status: 'pending' },
+          { id: '1', content: 'Task 2', status: 'pending' },
+        ],
+      };
+
+      const result = tool.validateToolParams(params);
+      expect(result).toContain('unique');
+    });
+  });
+
+  describe('execute', () => {
+    it('should create new todos file when none exists', async () => {
+      const params: TodoWriteParams = {
+        todos: [
+          { id: '1', content: 'Task 1', status: 'pending' },
+          { id: '2', content: 'Task 2', status: 'in_progress' },
+        ],
+      };
+
+      // Mock file not existing
+      mockFs.readFile.mockRejectedValue({ code: 'ENOENT' });
+      mockFs.mkdir.mockResolvedValue(undefined);
+      mockFs.writeFile.mockResolvedValue(undefined);
+
+      const invocation = tool.build(params);
+      const result = await invocation.execute(mockAbortSignal);
+
+      expect(result.llmContent).toContain('success');
+      expect(result.returnDisplay).toEqual({
+        type: 'todo_list',
+        todos: [
+          { id: '1', content: 'Task 1', status: 'pending' },
+          { id: '2', content: 'Task 2', status: 'in_progress' },
+        ],
+      });
+      expect(mockFs.writeFile).toHaveBeenCalledWith(
+        expect.stringContaining('test-session-123.json'),
+        expect.stringContaining('"todos"'),
+        'utf-8',
+      );
+    });
+
+    it('should replace todos with new ones', async () => {
+      const existingTodos = [
+        { id: '1', content: 'Existing Task', status: 'completed' },
+      ];
+
+      const params: TodoWriteParams = {
+        todos: [
+          { id: '1', content: 'Updated Task', status: 'completed' },
+          { id: '2', content: 'New Task', status: 'pending' },
+        ],
+      };
+
+      // Mock existing file
+      mockFs.readFile.mockResolvedValue(
+        JSON.stringify({ todos: existingTodos }),
+      );
+      mockFs.mkdir.mockResolvedValue(undefined);
+      mockFs.writeFile.mockResolvedValue(undefined);
+
+      const invocation = tool.build(params);
+      const result = await invocation.execute(mockAbortSignal);
+
+      expect(result.llmContent).toContain('success');
+      expect(result.returnDisplay).toEqual({
+        type: 'todo_list',
+        todos: [
+          { id: '1', content: 'Updated Task', status: 'completed' },
+          { id: '2', content: 'New Task', status: 'pending' },
+        ],
+      });
+      expect(mockFs.writeFile).toHaveBeenCalledWith(
+        expect.stringContaining('test-session-123.json'),
+        expect.stringMatching(/"Updated Task"/),
+        'utf-8',
+      );
+    });
+
+    it('should handle file write errors', async () => {
+      const params: TodoWriteParams = {
+        todos: [
+          { id: '1', content: 'Task 1', status: 'pending' },
+          { id: '2', content: 'Task 2', status: 'pending' },
+        ],
+      };
+
+      mockFs.readFile.mockRejectedValue({ code: 'ENOENT' });
+      mockFs.mkdir.mockResolvedValue(undefined);
+      mockFs.writeFile.mockRejectedValue(new Error('Write failed'));
+
+      const invocation = tool.build(params);
+      const result = await invocation.execute(mockAbortSignal);
+
+      expect(result.llmContent).toContain('"success":false');
+      expect(result.returnDisplay).toContain('Error writing todos');
+    });
+
+    it('should handle empty todos array', async () => {
+      const params: TodoWriteParams = {
+        todos: [],
+      };
+
+      mockFs.mkdir.mockResolvedValue(undefined);
+      mockFs.writeFile.mockResolvedValue(undefined);
+
+      const invocation = tool.build(params);
+      const result = await invocation.execute(mockAbortSignal);
+
+      expect(result.llmContent).toContain('success');
+      expect(result.returnDisplay).toEqual({
+        type: 'todo_list',
+        todos: [],
+      });
+      expect(mockFs.writeFile).toHaveBeenCalledWith(
+        expect.stringContaining('test-session-123.json'),
+        expect.stringContaining('"todos"'),
+        'utf-8',
+      );
+    });
+  });
+
+  describe('tool properties', () => {
+    it('should have correct tool name', () => {
+      expect(TodoWriteTool.Name).toBe('todo_write');
+      expect(tool.name).toBe('todo_write');
+    });
+
+    it('should have correct display name', () => {
+      expect(tool.displayName).toBe('Todo Write');
+    });
+
+    it('should have correct kind', () => {
+      expect(tool.kind).toBe('think');
+    });
+
+    it('should have schema with required properties', () => {
+      const schema = tool.schema;
+      expect(schema.name).toBe('todo_write');
+      expect(schema.parametersJsonSchema).toHaveProperty('properties.todos');
+      expect(schema.parametersJsonSchema).not.toHaveProperty(
+        'properties.merge',
+      );
+    });
+  });
+
+  describe('getDescription', () => {
+    it('should return "Create todos" when no todos file exists', () => {
+      // Mock existsSync to return false (file doesn't exist)
+      mockFsSync.existsSync.mockReturnValue(false);
+
+      const params = {
+        todos: [{ id: '1', content: 'Test todo', status: 'pending' as const }],
+      };
+      const invocation = tool.build(params);
+      expect(invocation.getDescription()).toBe('Create todos');
+    });
+
+    it('should return "Update todos" when todos file exists', () => {
+      // Mock existsSync to return true (file exists)
+      mockFsSync.existsSync.mockReturnValue(true);
+
+      const params = {
+        todos: [
+          { id: '1', content: 'Updated todo', status: 'completed' as const },
+        ],
+      };
+      const invocation = tool.build(params);
+      expect(invocation.getDescription()).toBe('Update todos');
+    });
+  });
+});

projects/ui/qwen-code/packages/core/src/tools/todoWrite.ts

@@ -0,0 +1,458 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import {
+  BaseDeclarativeTool,
+  BaseToolInvocation,
+  Kind,
+  ToolResult,
+} from './tools.js';
+import { FunctionDeclaration } from '@google/genai';
+import * as fs from 'fs/promises';
+import * as fsSync from 'fs';
+import * as path from 'path';
+import * as process from 'process';
+
+import { QWEN_DIR } from '../utils/paths.js';
+import { Config } from '../config/config.js';
+
+export interface TodoItem {
+  id: string;
+  content: string;
+  status: 'pending' | 'in_progress' | 'completed';
+}
+
+export interface TodoWriteParams {
+  todos: TodoItem[];
+  modified_by_user?: boolean;
+  modified_content?: string;
+}
+
+const todoWriteToolSchemaData: FunctionDeclaration = {
+  name: 'todo_write',
+  description:
+    'Creates and manages a structured task list for your current coding session. This helps track progress, organize complex tasks, and demonstrate thoroughness.',
+  parametersJsonSchema: {
+    type: 'object',
+    properties: {
+      todos: {
+        type: 'array',
+        items: {
+          type: 'object',
+          properties: {
+            content: {
+              type: 'string',
+              minLength: 1,
+            },
+            status: {
+              type: 'string',
+              enum: ['pending', 'in_progress', 'completed'],
+            },
+            id: {
+              type: 'string',
+            },
+          },
+          required: ['content', 'status', 'id'],
+          additionalProperties: false,
+        },
+        description: 'The updated todo list',
+      },
+    },
+    required: ['todos'],
+    $schema: 'http://json-schema.org/draft-07/schema#',
+  },
+};
+
+const todoWriteToolDescription = `
+Use this tool to create and manage a structured task list for your current coding session. This helps you track progress, organize complex tasks, and demonstrate thoroughness to the user.
+It also helps the user understand the progress of the task and overall progress of their requests.
+
+## When to Use This Tool
+Use this tool proactively in these scenarios:
+
+1. Complex multi-step tasks - When a task requires 3 or more distinct steps or actions
+2. Non-trivial and complex tasks - Tasks that require careful planning or multiple operations
+3. User explicitly requests todo list - When the user directly asks you to use the todo list
+4. User provides multiple tasks - When users provide a list of things to be done (numbered or comma-separated)
+5. After receiving new instructions - Immediately capture user requirements as todos
+6. When you start working on a task - Mark it as in_progress BEFORE beginning work. Ideally you should only have one todo as in_progress at a time
+7. After completing a task - Mark it as completed and add any new follow-up tasks discovered during implementation
+
+## When NOT to Use This Tool
+
+Skip using this tool when:
+1. There is only a single, straightforward task
+2. The task is trivial and tracking it provides no organizational benefit
+3. The task can be completed in less than 3 trivial steps
+4. The task is purely conversational or informational
+
+NOTE that you should not use this tool if there is only one trivial task to do. In this case you are better off just doing the task directly.
+
+## Examples of When to Use the Todo List
+
+<example>
+User: I want to add a dark mode toggle to the application settings. Make sure you run the tests and build when you're done!
+Assistant: I'll help add a dark mode toggle to your application settings. Let me create a todo list to track this implementation.
+*Creates todo list with the following items:*
+1. Create dark mode toggle component in Settings page
+2. Add dark mode state management (context/store)
+3. Implement CSS-in-JS styles for dark theme
+4. Update existing components to support theme switching
+5. Run tests and build process, addressing any failures or errors that occur
+*Begins working on the first task*
+
+<reasoning>
+The assistant used the todo list because:
+1. Adding dark mode is a multi-step feature requiring UI, state management, and styling changes
+2. The user explicitly requested tests and build be run afterward
+3. The assistant inferred that tests and build need to pass by adding "Ensure tests and build succeed" as the final task
+</reasoning>
+</example>
+
+<example>
+User: Help me rename the function getCwd to getCurrentWorkingDirectory across my project
+Assistant: Let me first search through your codebase to find all occurrences of 'getCwd'.
+*Uses grep or search tools to locate all instances of getCwd in the codebase*
+Assistant: I've found 15 instances of 'getCwd' across 8 different files. Let me create a todo list to track these changes.
+*Creates todo list with specific items for each file that needs updating*
+
+<reasoning>
+The assistant used the todo list because:
+1. First, the assistant searched to understand the scope of the task
+2. Upon finding multiple occurrences across different files, it determined this was a complex task with multiple steps
+3. The todo list helps ensure every instance is tracked and updated systematically
+4. This approach prevents missing any occurrences and maintains code consistency
+</reasoning>
+</example>
+
+
+<example>
+User: I need to implement these features for my e-commerce site: user registration, product catalog, shopping cart, and checkout flow.
+Assistant: I'll help implement these features. First, let's add all the features to the todo list.
+*Creates a todo list breaking down each feature into specific tasks based on the project architecture*
+Assistant: Let's start with user registration. This will involve creating database models, API endpoints, and frontend forms that integrate with your existing authentication system.
+
+<reasoning>
+The assistant used the todo list because:
+1. The user provided multiple complex features to implement in a comma separated list
+2. The todo list helps organize these large features into manageable tasks
+3. This approach allows for tracking progress across the entire implementation
+</reasoning>
+</example>
+
+<example>
+User: Can you help optimize my React application? It's rendering slowly and has performance issues.</user>
+Assistant: I'll help optimize your React application. First, let me examine your codebase to identify potential performance bottlenecks.
+*Reviews component structure, render patterns, state management, and data fetching*
+Assistant: After analyzing your codebase, I've identified several performance issues. Let me create a todo list to track our optimization efforts.
+*Creates todo list with items like: 1) Implement memoization for expensive calculations in ProductList, 2) Add virtualization for long lists in Dashboard, 3) Optimize image loading in Gallery component, 4) Fix state update loops in ShoppingCart, 5) Review bundle size and implement code splitting*
+Let's start by implementing memoization for the expensive calculations in your ProductList component.</assistant>
+
+<reasoning>
+The assistant used the todo list because:
+1. First, the assistant examined the codebase to identify specific performance issues
+2. Based on this analysis, it identified multiple optimization opportunities
+3. Performance optimization is a non-trivial task requiring multiple steps
+4. The todo list helps methodically track improvements across different components
+5. This systematic approach ensures all performance bottlenecks are addressed
+</reasoning>
+</example>
+
+## Examples of When NOT to Use the Todo List
+
+<example>
+User: How do I print 'Hello World' in Python?
+Assistant: In Python, you can print "Hello World" with this simple code:
+
+python
+print("Hello World")
+
+This will output the text "Hello World" to the console when executed.</assistant>
+
+<reasoning>
+The assistant did not use the todo list because this is a single, trivial task that can be completed in one step. There's no need to track multiple tasks or steps for such a straightforward request.
+</reasoning>
+</example>
+
+<example>
+User: What does the git status command do?
+Assistant: The git status command shows the current state of your working directory and staging area. It displays which changes have been staged, which haven't, and which files aren't being tracked by Git. This is a fundamental command for understanding the current state of your repository before making commits.
+
+<reasoning>
+The assistant did not use the todo list because this is an informational request with no actual coding task to complete. The user is simply asking for an explanation, not for the assistant to perform multiple steps or tasks.
+</reasoning>
+</example>
+
+<example>
+User: Can you add a comment to the calculateTotal function to explain what it does?
+Assistant: Sure, let me add a comment to the calculateTotal function to explain what it does.
+* Uses the Edit tool to add a comment to the calculateTotal function *
+
+<reasoning>
+The assistant did not use the todo list because this is a single, straightforward task confined to one location in the code. Adding a comment doesn't require tracking multiple steps or systematic organization.
+</reasoning>
+</example>
+
+<example>
+User: Run npm install for me and tell me what happens.
+Assistant: I'll run the npm install command for you.
+
+*Executes: npm install*
+
+The command completed successfully. Here's the output:
+[Output of npm install command]
+
+All dependencies have been installed according to your package.json file.
+
+<reasoning>
+The assistant did not use the todo list because this is a single command execution with immediate results. There are no multiple steps to track or organize, making the todo list unnecessary for this straightforward task.
+</reasoning>
+</example>
+
+## Task States and Management
+
+1. **Task States**: Use these states to track progress:
+   - pending: Task not yet started
+   - in_progress: Currently working on (limit to ONE task at a time)
+   - completed: Task finished successfully
+
+2. **Task Management**:
+   - Update task status in real-time as you work
+   - Mark tasks complete IMMEDIATELY after finishing (don't batch completions)
+   - Only have ONE task in_progress at any time
+   - Complete current tasks before starting new ones
+   - Remove tasks that are no longer relevant from the list entirely
+
+3. **Task Completion Requirements**:
+   - ONLY mark a task as completed when you have FULLY accomplished it
+   - If you encounter errors, blockers, or cannot finish, keep the task as in_progress
+   - When blocked, create a new task describing what needs to be resolved
+   - Never mark a task as completed if:
+     - Tests are failing
+     - Implementation is partial
+     - You encountered unresolved errors
+     - You couldn't find necessary files or dependencies
+
+4. **Task Breakdown**:
+   - Create specific, actionable items
+   - Break complex tasks into smaller, manageable steps
+   - Use clear, descriptive task names
+
+When in doubt, use this tool. Being proactive with task management demonstrates attentiveness and ensures you complete all requirements successfully.
+`;
+
+const TODO_SUBDIR = 'todos';
+
+function getTodoFilePath(sessionId?: string): string {
+  const homeDir =
+    process.env['HOME'] || process.env['USERPROFILE'] || process.cwd();
+  const todoDir = path.join(homeDir, QWEN_DIR, TODO_SUBDIR);
+
+  // Use sessionId if provided, otherwise fall back to 'default'
+  const filename = `${sessionId || 'default'}.json`;
+  return path.join(todoDir, filename);
+}
+
+/**
+ * Reads the current todos from the file system
+ */
+async function readTodosFromFile(sessionId?: string): Promise<TodoItem[]> {
+  try {
+    const todoFilePath = getTodoFilePath(sessionId);
+    const content = await fs.readFile(todoFilePath, 'utf-8');
+    const data = JSON.parse(content);
+    return Array.isArray(data.todos) ? data.todos : [];
+  } catch (err) {
+    const error = err as Error & { code?: string };
+    if (!(error instanceof Error) || error.code !== 'ENOENT') {
+      throw err;
+    }
+    return [];
+  }
+}
+
+/**
+ * Writes todos to the file system
+ */
+async function writeTodosToFile(
+  todos: TodoItem[],
+  sessionId?: string,
+): Promise<void> {
+  const todoFilePath = getTodoFilePath(sessionId);
+  const todoDir = path.dirname(todoFilePath);
+
+  await fs.mkdir(todoDir, { recursive: true });
+
+  const data = {
+    todos,
+    sessionId: sessionId || 'default',
+  };
+
+  await fs.writeFile(todoFilePath, JSON.stringify(data, null, 2), 'utf-8');
+}
+
+class TodoWriteToolInvocation extends BaseToolInvocation<
+  TodoWriteParams,
+  ToolResult
+> {
+  private operationType: 'create' | 'update';
+
+  constructor(
+    private readonly config: Config,
+    params: TodoWriteParams,
+    operationType: 'create' | 'update' = 'update',
+  ) {
+    super(params);
+    this.operationType = operationType;
+  }
+
+  getDescription(): string {
+    return this.operationType === 'create' ? 'Create todos' : 'Update todos';
+  }
+
+  override async shouldConfirmExecute(
+    _abortSignal: AbortSignal,
+  ): Promise<false> {
+    // Todo operations should execute automatically without user confirmation
+    return false;
+  }
+
+  async execute(_signal: AbortSignal): Promise<ToolResult> {
+    const { todos, modified_by_user, modified_content } = this.params;
+    const sessionId = this.config.getSessionId();
+
+    try {
+      let finalTodos: TodoItem[];
+
+      if (modified_by_user && modified_content !== undefined) {
+        // User modified the content in external editor, parse it directly
+        const data = JSON.parse(modified_content);
+        finalTodos = Array.isArray(data.todos) ? data.todos : [];
+      } else {
+        // Use the normal todo logic - simply replace with new todos
+        finalTodos = todos;
+      }
+
+      await writeTodosToFile(finalTodos, sessionId);
+
+      // Create structured display object for rich UI rendering
+      const todoResultDisplay = {
+        type: 'todo_list' as const,
+        todos: finalTodos,
+      };
+
+      return {
+        llmContent: JSON.stringify({
+          success: true,
+          todos: finalTodos,
+        }),
+        returnDisplay: todoResultDisplay,
+      };
+    } catch (error) {
+      const errorMessage =
+        error instanceof Error ? error.message : String(error);
+      console.error(
+        `[TodoWriteTool] Error executing todo_write: ${errorMessage}`,
+      );
+      return {
+        llmContent: JSON.stringify({
+          success: false,
+          error: `Failed to write todos. Detail: ${errorMessage}`,
+        }),
+        returnDisplay: `Error writing todos: ${errorMessage}`,
+      };
+    }
+  }
+}
+
+/**
+ * Utility function to read todos for a specific session (useful for session recovery)
+ */
+export async function readTodosForSession(
+  sessionId?: string,
+): Promise<TodoItem[]> {
+  return readTodosFromFile(sessionId);
+}
+
+/**
+ * Utility function to list all todo files in the todos directory
+ */
+export async function listTodoSessions(): Promise<string[]> {
+  try {
+    const homeDir =
+      process.env['HOME'] || process.env['USERPROFILE'] || process.cwd();
+    const todoDir = path.join(homeDir, QWEN_DIR, TODO_SUBDIR);
+    const files = await fs.readdir(todoDir);
+    return files
+      .filter((file: string) => file.endsWith('.json'))
+      .map((file: string) => file.replace('.json', ''));
+  } catch (err) {
+    const error = err as Error & { code?: string };
+    if (!(error instanceof Error) || error.code !== 'ENOENT') {
+      throw err;
+    }
+    return [];
+  }
+}
+
+export class TodoWriteTool extends BaseDeclarativeTool<
+  TodoWriteParams,
+  ToolResult
+> {
+  static readonly Name: string = todoWriteToolSchemaData.name!;
+
+  constructor(private readonly config: Config) {
+    super(
+      TodoWriteTool.Name,
+      'Todo Write',
+      todoWriteToolDescription,
+      Kind.Think,
+      todoWriteToolSchemaData.parametersJsonSchema as Record<string, unknown>,
+    );
+  }
+
+  override validateToolParams(params: TodoWriteParams): string | null {
+    // Validate todos array
+    if (!Array.isArray(params.todos)) {
+      return 'Parameter "todos" must be an array.';
+    }
+
+    // Validate individual todos
+    for (const todo of params.todos) {
+      if (!todo.id || typeof todo.id !== 'string' || todo.id.trim() === '') {
+        return 'Each todo must have a non-empty "id" string.';
+      }
+      if (
+        !todo.content ||
+        typeof todo.content !== 'string' ||
+        todo.content.trim() === ''
+      ) {
+        return 'Each todo must have a non-empty "content" string.';
+      }
+      if (!['pending', 'in_progress', 'completed'].includes(todo.status)) {
+        return 'Each todo must have a valid "status" (pending, in_progress, completed).';
+      }
+    }
+
+    // Check for duplicate IDs
+    const ids = params.todos.map((todo) => todo.id);
+    const uniqueIds = new Set(ids);
+    if (ids.length !== uniqueIds.size) {
+      return 'Todo IDs must be unique within the array.';
+    }
+
+    return null;
+  }
+
+  protected createInvocation(params: TodoWriteParams) {
+    // Determine if this is a create or update operation by checking if todos file exists
+    const sessionId = this.config.getSessionId();
+    const todoFilePath = getTodoFilePath(sessionId);
+    const operationType = fsSync.existsSync(todoFilePath) ? 'update' : 'create';
+
+    return new TodoWriteToolInvocation(this.config, params, operationType);
+  }
+}

projects/ui/qwen-code/packages/core/src/tools/tool-error.ts

@@ -0,0 +1,33 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * A type-safe enum for tool-related errors.
+ */
+export enum ToolErrorType {
+  // General Errors
+  INVALID_TOOL_PARAMS = 'invalid_tool_params',
+  UNKNOWN = 'unknown',
+  UNHANDLED_EXCEPTION = 'unhandled_exception',
+  TOOL_NOT_REGISTERED = 'tool_not_registered',
+  EXECUTION_FAILED = 'execution_failed',
+
+  // File System Errors
+  FILE_NOT_FOUND = 'file_not_found',
+  FILE_WRITE_FAILURE = 'file_write_failure',
+  READ_CONTENT_FAILURE = 'read_content_failure',
+  ATTEMPT_TO_CREATE_EXISTING_FILE = 'attempt_to_create_existing_file',
+  FILE_TOO_LARGE = 'file_too_large',
+  PERMISSION_DENIED = 'permission_denied',
+  NO_SPACE_LEFT = 'no_space_left',
+  TARGET_IS_DIRECTORY = 'target_is_directory',
+
+  // Edit-specific Errors
+  EDIT_PREPARATION_FAILURE = 'edit_preparation_failure',
+  EDIT_NO_OCCURRENCE_FOUND = 'edit_no_occurrence_found',
+  EDIT_EXPECTED_OCCURRENCE_MISMATCH = 'edit_expected_occurrence_mismatch',
+  EDIT_NO_CHANGE = 'edit_no_change',
+}

projects/ui/qwen-code/packages/core/src/tools/tool-registry.test.ts

@@ -0,0 +1,334 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import {
+  describe,
+  it,
+  expect,
+  vi,
+  beforeEach,
+  afterEach,
+  Mocked,
+} from 'vitest';
+import { Config, ConfigParameters, ApprovalMode } from '../config/config.js';
+import { ToolRegistry, DiscoveredTool } from './tool-registry.js';
+import { DiscoveredMCPTool } from './mcp-tool.js';
+import { FunctionDeclaration, CallableTool, mcpToTool } from '@google/genai';
+import { spawn } from 'node:child_process';
+import fs from 'node:fs';
+import { MockTool } from '../test-utils/tools.js';
+
+import { McpClientManager } from './mcp-client-manager.js';
+
+vi.mock('node:fs');
+
+// Mock ./mcp-client.js to control its behavior within tool-registry tests
+vi.mock('./mcp-client.js', async () => {
+  const originalModule = await vi.importActual('./mcp-client.js');
+  return {
+    ...originalModule,
+  };
+});
+
+// Mock node:child_process
+vi.mock('node:child_process', async () => {
+  const actual = await vi.importActual('node:child_process');
+  return {
+    ...actual,
+    execSync: vi.fn(),
+    spawn: vi.fn(),
+  };
+});
+
+// Mock MCP SDK Client and Transports
+const mockMcpClientConnect = vi.fn();
+const mockMcpClientOnError = vi.fn();
+const mockStdioTransportClose = vi.fn();
+const mockSseTransportClose = vi.fn();
+
+vi.mock('@modelcontextprotocol/sdk/client/index.js', () => {
+  const MockClient = vi.fn().mockImplementation(() => ({
+    connect: mockMcpClientConnect,
+    set onerror(handler: any) {
+      mockMcpClientOnError(handler);
+    },
+  }));
+  return { Client: MockClient };
+});
+
+vi.mock('@modelcontextprotocol/sdk/client/stdio.js', () => {
+  const MockStdioClientTransport = vi.fn().mockImplementation(() => ({
+    stderr: {
+      on: vi.fn(),
+    },
+    close: mockStdioTransportClose,
+  }));
+  return { StdioClientTransport: MockStdioClientTransport };
+});
+
+vi.mock('@modelcontextprotocol/sdk/client/sse.js', () => {
+  const MockSSEClientTransport = vi.fn().mockImplementation(() => ({
+    close: mockSseTransportClose,
+  }));
+  return { SSEClientTransport: MockSSEClientTransport };
+});
+
+// Mock @google/genai mcpToTool
+vi.mock('@google/genai', async () => {
+  const actualGenai =
+    await vi.importActual<typeof import('@google/genai')>('@google/genai');
+  return {
+    ...actualGenai,
+    mcpToTool: vi.fn().mockImplementation(() => ({
+      tool: vi.fn().mockResolvedValue({ functionDeclarations: [] }),
+      callTool: vi.fn(),
+    })),
+  };
+});
+
+// Helper to create a mock CallableTool for specific test needs
+const createMockCallableTool = (
+  toolDeclarations: FunctionDeclaration[],
+): Mocked<CallableTool> => ({
+  tool: vi.fn().mockResolvedValue({ functionDeclarations: toolDeclarations }),
+  callTool: vi.fn(),
+});
+
+const baseConfigParams: ConfigParameters = {
+  cwd: '/tmp',
+  model: 'test-model',
+  embeddingModel: 'test-embedding-model',
+  sandbox: undefined,
+  targetDir: '/test/dir',
+  debugMode: false,
+  userMemory: '',
+  geminiMdFileCount: 0,
+  approvalMode: ApprovalMode.DEFAULT,
+  sessionId: 'test-session-id',
+};
+
+describe('ToolRegistry', () => {
+  let config: Config;
+  let toolRegistry: ToolRegistry;
+  let mockConfigGetToolDiscoveryCommand: ReturnType<typeof vi.spyOn>;
+
+  beforeEach(() => {
+    vi.mocked(fs.existsSync).mockReturnValue(true);
+    vi.mocked(fs.statSync).mockReturnValue({
+      isDirectory: () => true,
+    } as fs.Stats);
+    config = new Config(baseConfigParams);
+    toolRegistry = new ToolRegistry(config);
+    vi.spyOn(console, 'warn').mockImplementation(() => {});
+    vi.spyOn(console, 'error').mockImplementation(() => {});
+    vi.spyOn(console, 'debug').mockImplementation(() => {});
+    vi.spyOn(console, 'log').mockImplementation(() => {});
+
+    mockMcpClientConnect.mockReset().mockResolvedValue(undefined);
+    mockStdioTransportClose.mockReset();
+    mockSseTransportClose.mockReset();
+    vi.mocked(mcpToTool).mockClear();
+    vi.mocked(mcpToTool).mockReturnValue(createMockCallableTool([]));
+
+    mockConfigGetToolDiscoveryCommand = vi.spyOn(
+      config,
+      'getToolDiscoveryCommand',
+    );
+    vi.spyOn(config, 'getMcpServers');
+    vi.spyOn(config, 'getMcpServerCommand');
+    vi.spyOn(config, 'getPromptRegistry').mockReturnValue({
+      clear: vi.fn(),
+      removePromptsByServer: vi.fn(),
+    } as any);
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  describe('registerTool', () => {
+    it('should register a new tool', () => {
+      const tool = new MockTool();
+      toolRegistry.registerTool(tool);
+      expect(toolRegistry.getTool('mock-tool')).toBe(tool);
+    });
+  });
+
+  describe('getAllTools', () => {
+    it('should return all registered tools sorted alphabetically by displayName', () => {
+      // Register tools with displayNames in non-alphabetical order
+      const toolC = new MockTool('c-tool', 'Tool C');
+      const toolA = new MockTool('a-tool', 'Tool A');
+      const toolB = new MockTool('b-tool', 'Tool B');
+
+      toolRegistry.registerTool(toolC);
+      toolRegistry.registerTool(toolA);
+      toolRegistry.registerTool(toolB);
+
+      const allTools = toolRegistry.getAllTools();
+      const displayNames = allTools.map((t) => t.displayName);
+
+      // Assert that the returned array is sorted by displayName
+      expect(displayNames).toEqual(['Tool A', 'Tool B', 'Tool C']);
+    });
+  });
+
+  describe('getToolsByServer', () => {
+    it('should return an empty array if no tools match the server name', () => {
+      toolRegistry.registerTool(new MockTool());
+      expect(toolRegistry.getToolsByServer('any-mcp-server')).toEqual([]);
+    });
+
+    it('should return only tools matching the server name, sorted by name', async () => {
+      const server1Name = 'mcp-server-uno';
+      const server2Name = 'mcp-server-dos';
+      const mockCallable = {} as CallableTool;
+      const mcpTool1_c = new DiscoveredMCPTool(
+        mockCallable,
+        server1Name,
+        'zebra-tool',
+        'd1',
+        {},
+      );
+      const mcpTool1_a = new DiscoveredMCPTool(
+        mockCallable,
+        server1Name,
+        'apple-tool',
+        'd2',
+        {},
+      );
+      const mcpTool1_b = new DiscoveredMCPTool(
+        mockCallable,
+        server1Name,
+        'banana-tool',
+        'd3',
+        {},
+      );
+
+      const mcpTool2 = new DiscoveredMCPTool(
+        mockCallable,
+        server2Name,
+        'tool-on-server2',
+        'd4',
+        {},
+      );
+      const nonMcpTool = new MockTool('regular-tool');
+
+      toolRegistry.registerTool(mcpTool1_c);
+      toolRegistry.registerTool(mcpTool1_a);
+      toolRegistry.registerTool(mcpTool1_b);
+      toolRegistry.registerTool(mcpTool2);
+      toolRegistry.registerTool(nonMcpTool);
+
+      const toolsFromServer1 = toolRegistry.getToolsByServer(server1Name);
+      const toolNames = toolsFromServer1.map((t) => t.name);
+
+      // Assert that the array has the correct tools and is sorted by name
+      expect(toolsFromServer1).toHaveLength(3);
+      expect(toolNames).toEqual(['apple-tool', 'banana-tool', 'zebra-tool']);
+
+      // Assert that all returned tools are indeed from the correct server
+      for (const tool of toolsFromServer1) {
+        expect((tool as DiscoveredMCPTool).serverName).toBe(server1Name);
+      }
+
+      // Assert that the other server's tools are returned correctly
+      const toolsFromServer2 = toolRegistry.getToolsByServer(server2Name);
+      expect(toolsFromServer2).toHaveLength(1);
+      expect(toolsFromServer2[0].name).toBe(mcpTool2.name);
+    });
+  });
+
+  describe('discoverTools', () => {
+    it('should will preserve tool parametersJsonSchema during discovery from command', async () => {
+      const discoveryCommand = 'my-discovery-command';
+      mockConfigGetToolDiscoveryCommand.mockReturnValue(discoveryCommand);
+
+      const unsanitizedToolDeclaration: FunctionDeclaration = {
+        name: 'tool-with-bad-format',
+        description: 'A tool with an invalid format property',
+        parametersJsonSchema: {
+          type: 'object',
+          properties: {
+            some_string: {
+              type: 'string',
+              format: 'uuid', // This is an unsupported format
+            },
+          },
+        },
+      };
+
+      const mockSpawn = vi.mocked(spawn);
+      const mockChildProcess = {
+        stdout: { on: vi.fn() },
+        stderr: { on: vi.fn() },
+        on: vi.fn(),
+      };
+      mockSpawn.mockReturnValue(mockChildProcess as any);
+
+      // Simulate stdout data
+      mockChildProcess.stdout.on.mockImplementation((event, callback) => {
+        if (event === 'data') {
+          callback(
+            Buffer.from(
+              JSON.stringify([
+                { function_declarations: [unsanitizedToolDeclaration] },
+              ]),
+            ),
+          );
+        }
+        return mockChildProcess as any;
+      });
+
+      // Simulate process close
+      mockChildProcess.on.mockImplementation((event, callback) => {
+        if (event === 'close') {
+          callback(0);
+        }
+        return mockChildProcess as any;
+      });
+
+      await toolRegistry.discoverAllTools();
+
+      const discoveredTool = toolRegistry.getTool('tool-with-bad-format');
+      expect(discoveredTool).toBeDefined();
+
+      const registeredParams = (discoveredTool as DiscoveredTool).schema
+        .parametersJsonSchema;
+      expect(registeredParams).toStrictEqual({
+        type: 'object',
+        properties: {
+          some_string: {
+            type: 'string',
+            format: 'uuid',
+          },
+        },
+      });
+    });
+
+    it('should discover tools using MCP servers defined in getMcpServers', async () => {
+      const discoverSpy = vi.spyOn(
+        McpClientManager.prototype,
+        'discoverAllMcpTools',
+      );
+      mockConfigGetToolDiscoveryCommand.mockReturnValue(undefined);
+      vi.spyOn(config, 'getMcpServerCommand').mockReturnValue(undefined);
+      const mcpServerConfigVal = {
+        'my-mcp-server': {
+          command: 'mcp-server-cmd',
+          args: ['--port', '1234'],
+          trust: true,
+        },
+      };
+      vi.spyOn(config, 'getMcpServers').mockReturnValue(mcpServerConfigVal);
+
+      await toolRegistry.discoverAllTools();
+
+      expect(discoverSpy).toHaveBeenCalled();
+    });
+  });
+});

projects/ui/qwen-code/packages/core/src/tools/tool-registry.ts

@@ -0,0 +1,464 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { FunctionDeclaration } from '@google/genai';
+import {
+  AnyDeclarativeTool,
+  Kind,
+  ToolResult,
+  BaseDeclarativeTool,
+  BaseToolInvocation,
+  ToolInvocation,
+} from './tools.js';
+import { Config } from '../config/config.js';
+import { spawn } from 'node:child_process';
+import { StringDecoder } from 'node:string_decoder';
+import { connectAndDiscover } from './mcp-client.js';
+import { McpClientManager } from './mcp-client-manager.js';
+import { DiscoveredMCPTool } from './mcp-tool.js';
+import { parse } from 'shell-quote';
+
+type ToolParams = Record<string, unknown>;
+
+class DiscoveredToolInvocation extends BaseToolInvocation<
+  ToolParams,
+  ToolResult
+> {
+  constructor(
+    private readonly config: Config,
+    private readonly toolName: string,
+    params: ToolParams,
+  ) {
+    super(params);
+  }
+
+  getDescription(): string {
+    return `Calling discovered tool: ${this.toolName}`;
+  }
+
+  async execute(
+    _signal: AbortSignal,
+    _updateOutput?: (output: string) => void,
+  ): Promise<ToolResult> {
+    const callCommand = this.config.getToolCallCommand()!;
+    const child = spawn(callCommand, [this.toolName]);
+    child.stdin.write(JSON.stringify(this.params));
+    child.stdin.end();
+
+    let stdout = '';
+    let stderr = '';
+    let error: Error | null = null;
+    let code: number | null = null;
+    let signal: NodeJS.Signals | null = null;
+
+    await new Promise<void>((resolve) => {
+      const onStdout = (data: Buffer) => {
+        stdout += data?.toString();
+      };
+
+      const onStderr = (data: Buffer) => {
+        stderr += data?.toString();
+      };
+
+      const onError = (err: Error) => {
+        error = err;
+      };
+
+      const onClose = (
+        _code: number | null,
+        _signal: NodeJS.Signals | null,
+      ) => {
+        code = _code;
+        signal = _signal;
+        cleanup();
+        resolve();
+      };
+
+      const cleanup = () => {
+        child.stdout.removeListener('data', onStdout);
+        child.stderr.removeListener('data', onStderr);
+        child.removeListener('error', onError);
+        child.removeListener('close', onClose);
+        if (child.connected) {
+          child.disconnect();
+        }
+      };
+
+      child.stdout.on('data', onStdout);
+      child.stderr.on('data', onStderr);
+      child.on('error', onError);
+      child.on('close', onClose);
+    });
+
+    // if there is any error, non-zero exit code, signal, or stderr, return error details instead of stdout
+    if (error || code !== 0 || signal || stderr) {
+      const llmContent = [
+        `Stdout: ${stdout || '(empty)'}`,
+        `Stderr: ${stderr || '(empty)'}`,
+        `Error: ${error ?? '(none)'}`,
+        `Exit Code: ${code ?? '(none)'}`,
+        `Signal: ${signal ?? '(none)'}`,
+      ].join('\n');
+      return {
+        llmContent,
+        returnDisplay: llmContent,
+      };
+    }
+
+    return {
+      llmContent: stdout,
+      returnDisplay: stdout,
+    };
+  }
+}
+
+export class DiscoveredTool extends BaseDeclarativeTool<
+  ToolParams,
+  ToolResult
+> {
+  constructor(
+    private readonly config: Config,
+    name: string,
+    override readonly description: string,
+    override readonly parameterSchema: Record<string, unknown>,
+  ) {
+    const discoveryCmd = config.getToolDiscoveryCommand()!;
+    const callCommand = config.getToolCallCommand()!;
+    description += `
+
+This tool was discovered from the project by executing the command \`${discoveryCmd}\` on project root.
+When called, this tool will execute the command \`${callCommand} ${name}\` on project root.
+Tool discovery and call commands can be configured in project or user settings.
+
+When called, the tool call command is executed as a subprocess.
+On success, tool output is returned as a json string.
+Otherwise, the following information is returned:
+
+Stdout: Output on stdout stream. Can be \`(empty)\` or partial.
+Stderr: Output on stderr stream. Can be \`(empty)\` or partial.
+Error: Error or \`(none)\` if no error was reported for the subprocess.
+Exit Code: Exit code or \`(none)\` if terminated by signal.
+Signal: Signal number or \`(none)\` if no signal was received.
+`;
+    super(
+      name,
+      name,
+      description,
+      Kind.Other,
+      parameterSchema,
+      false, // isOutputMarkdown
+      false, // canUpdateOutput
+    );
+  }
+
+  protected createInvocation(
+    params: ToolParams,
+  ): ToolInvocation<ToolParams, ToolResult> {
+    return new DiscoveredToolInvocation(this.config, this.name, params);
+  }
+}
+
+export class ToolRegistry {
+  private tools: Map<string, AnyDeclarativeTool> = new Map();
+  private config: Config;
+  private mcpClientManager: McpClientManager;
+
+  constructor(config: Config) {
+    this.config = config;
+    this.mcpClientManager = new McpClientManager(
+      this.config.getMcpServers() ?? {},
+      this.config.getMcpServerCommand(),
+      this,
+      this.config.getPromptRegistry(),
+      this.config.getDebugMode(),
+      this.config.getWorkspaceContext(),
+    );
+  }
+
+  /**
+   * Registers a tool definition.
+   * @param tool - The tool object containing schema and execution logic.
+   */
+  registerTool(tool: AnyDeclarativeTool): void {
+    if (this.tools.has(tool.name)) {
+      if (tool instanceof DiscoveredMCPTool) {
+        tool = tool.asFullyQualifiedTool();
+      } else {
+        // Decide on behavior: throw error, log warning, or allow overwrite
+        console.warn(
+          `Tool with name "${tool.name}" is already registered. Overwriting.`,
+        );
+      }
+    }
+    this.tools.set(tool.name, tool);
+  }
+
+  private removeDiscoveredTools(): void {
+    for (const tool of this.tools.values()) {
+      if (tool instanceof DiscoveredTool || tool instanceof DiscoveredMCPTool) {
+        this.tools.delete(tool.name);
+      }
+    }
+  }
+
+  /**
+   * Removes all tools from a specific MCP server.
+   * @param serverName The name of the server to remove tools from.
+   */
+  removeMcpToolsByServer(serverName: string): void {
+    for (const [name, tool] of this.tools.entries()) {
+      if (tool instanceof DiscoveredMCPTool && tool.serverName === serverName) {
+        this.tools.delete(name);
+      }
+    }
+  }
+
+  /**
+   * Discovers tools from project (if available and configured).
+   * Can be called multiple times to update discovered tools.
+   * This will discover tools from the command line and from MCP servers.
+   */
+  async discoverAllTools(): Promise<void> {
+    // remove any previously discovered tools
+    this.removeDiscoveredTools();
+
+    this.config.getPromptRegistry().clear();
+
+    await this.discoverAndRegisterToolsFromCommand();
+
+    // discover tools using MCP servers, if configured
+    await this.mcpClientManager.discoverAllMcpTools();
+  }
+
+  /**
+   * Discovers tools from project (if available and configured).
+   * Can be called multiple times to update discovered tools.
+   * This will NOT discover tools from the command line, only from MCP servers.
+   */
+  async discoverMcpTools(): Promise<void> {
+    // remove any previously discovered tools
+    this.removeDiscoveredTools();
+
+    this.config.getPromptRegistry().clear();
+
+    // discover tools using MCP servers, if configured
+    await this.mcpClientManager.discoverAllMcpTools();
+  }
+
+  /**
+   * Restarts all MCP servers and re-discovers tools.
+   */
+  async restartMcpServers(): Promise<void> {
+    await this.discoverMcpTools();
+  }
+
+  /**
+   * Discover or re-discover tools for a single MCP server.
+   * @param serverName - The name of the server to discover tools from.
+   */
+  async discoverToolsForServer(serverName: string): Promise<void> {
+    // Remove any previously discovered tools from this server
+    for (const [name, tool] of this.tools.entries()) {
+      if (tool instanceof DiscoveredMCPTool && tool.serverName === serverName) {
+        this.tools.delete(name);
+      }
+    }
+
+    this.config.getPromptRegistry().removePromptsByServer(serverName);
+
+    const mcpServers = this.config.getMcpServers() ?? {};
+    const serverConfig = mcpServers[serverName];
+    if (serverConfig) {
+      await connectAndDiscover(
+        serverName,
+        serverConfig,
+        this,
+        this.config.getPromptRegistry(),
+        this.config.getDebugMode(),
+        this.config.getWorkspaceContext(),
+      );
+    }
+  }
+
+  private async discoverAndRegisterToolsFromCommand(): Promise<void> {
+    const discoveryCmd = this.config.getToolDiscoveryCommand();
+    if (!discoveryCmd) {
+      return;
+    }
+
+    try {
+      const cmdParts = parse(discoveryCmd);
+      if (cmdParts.length === 0) {
+        throw new Error(
+          'Tool discovery command is empty or contains only whitespace.',
+        );
+      }
+      const proc = spawn(cmdParts[0] as string, cmdParts.slice(1) as string[]);
+      let stdout = '';
+      const stdoutDecoder = new StringDecoder('utf8');
+      let stderr = '';
+      const stderrDecoder = new StringDecoder('utf8');
+      let sizeLimitExceeded = false;
+      const MAX_STDOUT_SIZE = 10 * 1024 * 1024; // 10MB limit
+      const MAX_STDERR_SIZE = 10 * 1024 * 1024; // 10MB limit
+
+      let stdoutByteLength = 0;
+      let stderrByteLength = 0;
+
+      proc.stdout.on('data', (data) => {
+        if (sizeLimitExceeded) return;
+        if (stdoutByteLength + data.length > MAX_STDOUT_SIZE) {
+          sizeLimitExceeded = true;
+          proc.kill();
+          return;
+        }
+        stdoutByteLength += data.length;
+        stdout += stdoutDecoder.write(data);
+      });
+
+      proc.stderr.on('data', (data) => {
+        if (sizeLimitExceeded) return;
+        if (stderrByteLength + data.length > MAX_STDERR_SIZE) {
+          sizeLimitExceeded = true;
+          proc.kill();
+          return;
+        }
+        stderrByteLength += data.length;
+        stderr += stderrDecoder.write(data);
+      });
+
+      await new Promise<void>((resolve, reject) => {
+        proc.on('error', reject);
+        proc.on('close', (code) => {
+          stdout += stdoutDecoder.end();
+          stderr += stderrDecoder.end();
+
+          if (sizeLimitExceeded) {
+            return reject(
+              new Error(
+                `Tool discovery command output exceeded size limit of ${MAX_STDOUT_SIZE} bytes.`,
+              ),
+            );
+          }
+
+          if (code !== 0) {
+            console.error(`Command failed with code ${code}`);
+            console.error(stderr);
+            return reject(
+              new Error(`Tool discovery command failed with exit code ${code}`),
+            );
+          }
+          resolve();
+        });
+      });
+
+      // execute discovery command and extract function declarations (w/ or w/o "tool" wrappers)
+      const functions: FunctionDeclaration[] = [];
+      const discoveredItems = JSON.parse(stdout.trim());
+
+      if (!discoveredItems || !Array.isArray(discoveredItems)) {
+        throw new Error(
+          'Tool discovery command did not return a JSON array of tools.',
+        );
+      }
+
+      for (const tool of discoveredItems) {
+        if (tool && typeof tool === 'object') {
+          if (Array.isArray(tool['function_declarations'])) {
+            functions.push(...tool['function_declarations']);
+          } else if (Array.isArray(tool['functionDeclarations'])) {
+            functions.push(...tool['functionDeclarations']);
+          } else if (tool['name']) {
+            functions.push(tool as FunctionDeclaration);
+          }
+        }
+      }
+      // register each function as a tool
+      for (const func of functions) {
+        if (!func.name) {
+          console.warn('Discovered a tool with no name. Skipping.');
+          continue;
+        }
+        const parameters =
+          func.parametersJsonSchema &&
+          typeof func.parametersJsonSchema === 'object' &&
+          !Array.isArray(func.parametersJsonSchema)
+            ? func.parametersJsonSchema
+            : {};
+        this.registerTool(
+          new DiscoveredTool(
+            this.config,
+            func.name,
+            func.description ?? '',
+            parameters as Record<string, unknown>,
+          ),
+        );
+      }
+    } catch (e) {
+      console.error(`Tool discovery command "${discoveryCmd}" failed:`, e);
+      throw e;
+    }
+  }
+
+  /**
+   * Retrieves the list of tool schemas (FunctionDeclaration array).
+   * Extracts the declarations from the ToolListUnion structure.
+   * Includes discovered (vs registered) tools if configured.
+   * @returns An array of FunctionDeclarations.
+   */
+  getFunctionDeclarations(): FunctionDeclaration[] {
+    const declarations: FunctionDeclaration[] = [];
+    this.tools.forEach((tool) => {
+      declarations.push(tool.schema);
+    });
+    return declarations;
+  }
+
+  /**
+   * Retrieves a filtered list of tool schemas based on a list of tool names.
+   * @param toolNames - An array of tool names to include.
+   * @returns An array of FunctionDeclarations for the specified tools.
+   */
+  getFunctionDeclarationsFiltered(toolNames: string[]): FunctionDeclaration[] {
+    const declarations: FunctionDeclaration[] = [];
+    for (const name of toolNames) {
+      const tool = this.tools.get(name);
+      if (tool) {
+        declarations.push(tool.schema);
+      }
+    }
+    return declarations;
+  }
+
+  /**
+   * Returns an array of all registered and discovered tool instances.
+   */
+  getAllTools(): AnyDeclarativeTool[] {
+    return Array.from(this.tools.values()).sort((a, b) =>
+      a.displayName.localeCompare(b.displayName),
+    );
+  }
+
+  /**
+   * Returns an array of tools registered from a specific MCP server.
+   */
+  getToolsByServer(serverName: string): AnyDeclarativeTool[] {
+    const serverTools: AnyDeclarativeTool[] = [];
+    for (const tool of this.tools.values()) {
+      if ((tool as DiscoveredMCPTool)?.serverName === serverName) {
+        serverTools.push(tool);
+      }
+    }
+    return serverTools.sort((a, b) => a.name.localeCompare(b.name));
+  }
+
+  /**
+   * Get the definition of a specific tool.
+   */
+  getTool(name: string): AnyDeclarativeTool | undefined {
+    return this.tools.get(name);
+  }
+}

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

@@ -0,0 +1,236 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { describe, it, expect, vi } from 'vitest';
+import {
+  DeclarativeTool,
+  hasCycleInSchema,
+  Kind,
+  ToolInvocation,
+  ToolResult,
+} from './tools.js';
+import { ToolErrorType } from './tool-error.js';
+
+class TestToolInvocation implements ToolInvocation<object, ToolResult> {
+  constructor(
+    readonly params: object,
+    private readonly executeFn: () => Promise<ToolResult>,
+  ) {}
+
+  getDescription(): string {
+    return 'A test invocation';
+  }
+
+  toolLocations() {
+    return [];
+  }
+
+  shouldConfirmExecute(): Promise<false> {
+    return Promise.resolve(false);
+  }
+
+  execute(): Promise<ToolResult> {
+    return this.executeFn();
+  }
+}
+
+class TestTool extends DeclarativeTool<object, ToolResult> {
+  private readonly buildFn: (params: object) => TestToolInvocation;
+
+  constructor(buildFn: (params: object) => TestToolInvocation) {
+    super('test-tool', 'Test Tool', 'A tool for testing', Kind.Other, {});
+    this.buildFn = buildFn;
+  }
+
+  build(params: object): ToolInvocation<object, ToolResult> {
+    return this.buildFn(params);
+  }
+}
+
+describe('DeclarativeTool', () => {
+  describe('validateBuildAndExecute', () => {
+    const abortSignal = new AbortController().signal;
+
+    it('should return INVALID_TOOL_PARAMS error if build fails', async () => {
+      const buildError = new Error('Invalid build parameters');
+      const buildFn = vi.fn().mockImplementation(() => {
+        throw buildError;
+      });
+      const tool = new TestTool(buildFn);
+      const params = { foo: 'bar' };
+
+      const result = await tool.validateBuildAndExecute(params, abortSignal);
+
+      expect(buildFn).toHaveBeenCalledWith(params);
+      expect(result).toEqual({
+        llmContent: `Error: Invalid parameters provided. Reason: ${buildError.message}`,
+        returnDisplay: buildError.message,
+        error: {
+          message: buildError.message,
+          type: ToolErrorType.INVALID_TOOL_PARAMS,
+        },
+      });
+    });
+
+    it('should return EXECUTION_FAILED error if execute fails', async () => {
+      const executeError = new Error('Execution failed');
+      const executeFn = vi.fn().mockRejectedValue(executeError);
+      const invocation = new TestToolInvocation({}, executeFn);
+      const buildFn = vi.fn().mockReturnValue(invocation);
+      const tool = new TestTool(buildFn);
+      const params = { foo: 'bar' };
+
+      const result = await tool.validateBuildAndExecute(params, abortSignal);
+
+      expect(buildFn).toHaveBeenCalledWith(params);
+      expect(executeFn).toHaveBeenCalled();
+      expect(result).toEqual({
+        llmContent: `Error: Tool call execution failed. Reason: ${executeError.message}`,
+        returnDisplay: executeError.message,
+        error: {
+          message: executeError.message,
+          type: ToolErrorType.EXECUTION_FAILED,
+        },
+      });
+    });
+
+    it('should return the result of execute on success', async () => {
+      const successResult: ToolResult = {
+        llmContent: 'Success!',
+        returnDisplay: 'Success!',
+        summary: 'Tool executed successfully',
+      };
+      const executeFn = vi.fn().mockResolvedValue(successResult);
+      const invocation = new TestToolInvocation({}, executeFn);
+      const buildFn = vi.fn().mockReturnValue(invocation);
+      const tool = new TestTool(buildFn);
+      const params = { foo: 'bar' };
+
+      const result = await tool.validateBuildAndExecute(params, abortSignal);
+
+      expect(buildFn).toHaveBeenCalledWith(params);
+      expect(executeFn).toHaveBeenCalled();
+      expect(result).toEqual(successResult);
+    });
+  });
+});
+
+describe('hasCycleInSchema', () => {
+  it('should detect a simple direct cycle', () => {
+    const schema = {
+      properties: {
+        data: {
+          $ref: '#/properties/data',
+        },
+      },
+    };
+    expect(hasCycleInSchema(schema)).toBe(true);
+  });
+
+  it('should detect a cycle from object properties referencing parent properties', () => {
+    const schema = {
+      type: 'object',
+      properties: {
+        data: {
+          type: 'object',
+          properties: {
+            child: { $ref: '#/properties/data' },
+          },
+        },
+      },
+    };
+    expect(hasCycleInSchema(schema)).toBe(true);
+  });
+
+  it('should detect a cycle from array items referencing parent properties', () => {
+    const schema = {
+      type: 'object',
+      properties: {
+        data: {
+          type: 'array',
+          items: {
+            type: 'object',
+            properties: {
+              child: { $ref: '#/properties/data/items' },
+            },
+          },
+        },
+      },
+    };
+    expect(hasCycleInSchema(schema)).toBe(true);
+  });
+
+  it('should detect a cycle between sibling properties', () => {
+    const schema = {
+      type: 'object',
+      properties: {
+        a: {
+          type: 'object',
+          properties: {
+            child: { $ref: '#/properties/b' },
+          },
+        },
+        b: {
+          type: 'object',
+          properties: {
+            child: { $ref: '#/properties/a' },
+          },
+        },
+      },
+    };
+    expect(hasCycleInSchema(schema)).toBe(true);
+  });
+
+  it('should not detect a cycle in a valid schema', () => {
+    const schema = {
+      type: 'object',
+      properties: {
+        name: { type: 'string' },
+        address: { $ref: '#/definitions/address' },
+      },
+      definitions: {
+        address: {
+          type: 'object',
+          properties: {
+            street: { type: 'string' },
+            city: { type: 'string' },
+          },
+        },
+      },
+    };
+    expect(hasCycleInSchema(schema)).toBe(false);
+  });
+
+  it('should handle non-cyclic sibling refs', () => {
+    const schema = {
+      properties: {
+        a: { $ref: '#/definitions/stringDef' },
+        b: { $ref: '#/definitions/stringDef' },
+      },
+      definitions: {
+        stringDef: { type: 'string' },
+      },
+    };
+    expect(hasCycleInSchema(schema)).toBe(false);
+  });
+
+  it('should handle nested but not cyclic refs', () => {
+    const schema = {
+      properties: {
+        a: { $ref: '#/definitions/defA' },
+      },
+      definitions: {
+        defA: { properties: { b: { $ref: '#/definitions/defB' } } },
+        defB: { type: 'string' },
+      },
+    };
+    expect(hasCycleInSchema(schema)).toBe(false);
+  });
+
+  it('should return false for an empty schema', () => {
+    expect(hasCycleInSchema({})).toBe(false);
+  });
+});

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

@@ -0,0 +1,529 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { FunctionDeclaration, PartListUnion } from '@google/genai';
+import { ToolErrorType } from './tool-error.js';
+import { DiffUpdateResult } from '../ide/ideContext.js';
+import { SchemaValidator } from '../utils/schemaValidator.js';
+
+/**
+ * Represents a validated and ready-to-execute tool call.
+ * An instance of this is created by a `ToolBuilder`.
+ */
+export interface ToolInvocation<
+  TParams extends object,
+  TResult extends ToolResult,
+> {
+  /**
+   * The validated parameters for this specific invocation.
+   */
+  params: TParams;
+
+  /**
+   * Gets a pre-execution description of the tool operation.
+   * @returns A markdown string describing what the tool will do.
+   */
+  getDescription(): string;
+
+  /**
+   * Determines what file system paths the tool will affect.
+   * @returns A list of such paths.
+   */
+  toolLocations(): ToolLocation[];
+
+  /**
+   * Determines if the tool should prompt for confirmation before execution.
+   * @returns Confirmation details or false if no confirmation is needed.
+   */
+  shouldConfirmExecute(
+    abortSignal: AbortSignal,
+  ): Promise<ToolCallConfirmationDetails | false>;
+
+  /**
+   * Executes the tool with the validated parameters.
+   * @param signal AbortSignal for tool cancellation.
+   * @param updateOutput Optional callback to stream output.
+   * @returns Result of the tool execution.
+   */
+  execute(
+    signal: AbortSignal,
+    updateOutput?: (output: string) => void,
+  ): Promise<TResult>;
+}
+
+/**
+ * A convenience base class for ToolInvocation.
+ */
+export abstract class BaseToolInvocation<
+  TParams extends object,
+  TResult extends ToolResult,
+> implements ToolInvocation<TParams, TResult>
+{
+  constructor(readonly params: TParams) {}
+
+  abstract getDescription(): string;
+
+  toolLocations(): ToolLocation[] {
+    return [];
+  }
+
+  shouldConfirmExecute(
+    _abortSignal: AbortSignal,
+  ): Promise<ToolCallConfirmationDetails | false> {
+    return Promise.resolve(false);
+  }
+
+  abstract execute(
+    signal: AbortSignal,
+    updateOutput?: (output: string) => void,
+  ): Promise<TResult>;
+}
+
+/**
+ * A type alias for a tool invocation where the specific parameter and result types are not known.
+ */
+export type AnyToolInvocation = ToolInvocation<object, ToolResult>;
+
+/**
+ * Interface for a tool builder that validates parameters and creates invocations.
+ */
+export interface ToolBuilder<
+  TParams extends object,
+  TResult extends ToolResult,
+> {
+  /**
+   * The internal name of the tool (used for API calls).
+   */
+  name: string;
+
+  /**
+   * The user-friendly display name of the tool.
+   */
+  displayName: string;
+
+  /**
+   * Description of what the tool does.
+   */
+  description: string;
+
+  /**
+   * The kind of tool for categorization and permissions
+   */
+  kind: Kind;
+
+  /**
+   * Function declaration schema from @google/genai.
+   */
+  schema: FunctionDeclaration;
+
+  /**
+   * Whether the tool's output should be rendered as markdown.
+   */
+  isOutputMarkdown: boolean;
+
+  /**
+   * Whether the tool supports live (streaming) output.
+   */
+  canUpdateOutput: boolean;
+
+  /**
+   * Validates raw parameters and builds a ready-to-execute invocation.
+   * @param params The raw, untrusted parameters from the model.
+   * @returns A valid `ToolInvocation` if successful. Throws an error if validation fails.
+   */
+  build(params: TParams): ToolInvocation<TParams, TResult>;
+}
+
+/**
+ * New base class for tools that separates validation from execution.
+ * New tools should extend this class.
+ */
+export abstract class DeclarativeTool<
+  TParams extends object,
+  TResult extends ToolResult,
+> implements ToolBuilder<TParams, TResult>
+{
+  constructor(
+    readonly name: string,
+    readonly displayName: string,
+    readonly description: string,
+    readonly kind: Kind,
+    readonly parameterSchema: unknown,
+    readonly isOutputMarkdown: boolean = true,
+    readonly canUpdateOutput: boolean = false,
+  ) {}
+
+  get schema(): FunctionDeclaration {
+    return {
+      name: this.name,
+      description: this.description,
+      parametersJsonSchema: this.parameterSchema,
+    };
+  }
+
+  /**
+   * Validates the raw tool parameters.
+   * Subclasses should override this to add custom validation logic
+   * beyond the JSON schema check.
+   * @param params The raw parameters from the model.
+   * @returns An error message string if invalid, null otherwise.
+   */
+  validateToolParams(_params: TParams): string | null {
+    // Base implementation can be extended by subclasses.
+    return null;
+  }
+
+  /**
+   * The core of the new pattern. It validates parameters and, if successful,
+   * returns a `ToolInvocation` object that encapsulates the logic for the
+   * specific, validated call.
+   * @param params The raw, untrusted parameters from the model.
+   * @returns A `ToolInvocation` instance.
+   */
+  abstract build(params: TParams): ToolInvocation<TParams, TResult>;
+
+  /**
+   * A convenience method that builds and executes the tool in one step.
+   * Throws an error if validation fails.
+   * @param params The raw, untrusted parameters from the model.
+   * @param signal AbortSignal for tool cancellation.
+   * @param updateOutput Optional callback to stream output.
+   * @returns The result of the tool execution.
+   */
+  async buildAndExecute(
+    params: TParams,
+    signal: AbortSignal,
+    updateOutput?: (output: string) => void,
+  ): Promise<TResult> {
+    const invocation = this.build(params);
+    return invocation.execute(signal, updateOutput);
+  }
+
+  /**
+   * Similar to `build` but never throws.
+   * @param params The raw, untrusted parameters from the model.
+   * @returns A `ToolInvocation` instance.
+   */
+  private silentBuild(
+    params: TParams,
+  ): ToolInvocation<TParams, TResult> | Error {
+    try {
+      return this.build(params);
+    } catch (e) {
+      if (e instanceof Error) {
+        return e;
+      }
+      return new Error(String(e));
+    }
+  }
+
+  /**
+   * A convenience method that builds and executes the tool in one step.
+   * Never throws.
+   * @param params The raw, untrusted parameters from the model.
+   * @params abortSignal a signal to abort.
+   * @returns The result of the tool execution.
+   */
+  async validateBuildAndExecute(
+    params: TParams,
+    abortSignal: AbortSignal,
+  ): Promise<ToolResult> {
+    const invocationOrError = this.silentBuild(params);
+    if (invocationOrError instanceof Error) {
+      const errorMessage = invocationOrError.message;
+      return {
+        llmContent: `Error: Invalid parameters provided. Reason: ${errorMessage}`,
+        returnDisplay: errorMessage,
+        error: {
+          message: errorMessage,
+          type: ToolErrorType.INVALID_TOOL_PARAMS,
+        },
+      };
+    }
+
+    try {
+      return await invocationOrError.execute(abortSignal);
+    } catch (error) {
+      const errorMessage =
+        error instanceof Error ? error.message : String(error);
+      return {
+        llmContent: `Error: Tool call execution failed. Reason: ${errorMessage}`,
+        returnDisplay: errorMessage,
+        error: {
+          message: errorMessage,
+          type: ToolErrorType.EXECUTION_FAILED,
+        },
+      };
+    }
+  }
+}
+
+/**
+ * New base class for declarative tools that separates validation from execution.
+ * New tools should extend this class, which provides a `build` method that
+ * validates parameters before deferring to a `createInvocation` method for
+ * the final `ToolInvocation` object instantiation.
+ */
+export abstract class BaseDeclarativeTool<
+  TParams extends object,
+  TResult extends ToolResult,
+> extends DeclarativeTool<TParams, TResult> {
+  build(params: TParams): ToolInvocation<TParams, TResult> {
+    const validationError = this.validateToolParams(params);
+    if (validationError) {
+      throw new Error(validationError);
+    }
+    return this.createInvocation(params);
+  }
+
+  override validateToolParams(params: TParams): string | null {
+    const errors = SchemaValidator.validate(
+      this.schema.parametersJsonSchema,
+      params,
+    );
+
+    if (errors) {
+      return errors;
+    }
+    return this.validateToolParamValues(params);
+  }
+
+  protected validateToolParamValues(_params: TParams): string | null {
+    // Base implementation can be extended by subclasses.
+    return null;
+  }
+
+  protected abstract createInvocation(
+    params: TParams,
+  ): ToolInvocation<TParams, TResult>;
+}
+
+/**
+ * A type alias for a declarative tool where the specific parameter and result types are not known.
+ */
+export type AnyDeclarativeTool = DeclarativeTool<object, ToolResult>;
+
+export interface ToolResult {
+  /**
+   * A short, one-line summary of the tool's action and result.
+   * e.g., "Read 5 files", "Wrote 256 bytes to foo.txt"
+   */
+  summary?: string;
+  /**
+   * Content meant to be included in LLM history.
+   * This should represent the factual outcome of the tool execution.
+   */
+  llmContent: PartListUnion;
+
+  /**
+   * Markdown string for user display.
+   * This provides a user-friendly summary or visualization of the result.
+   * NOTE: This might also be considered UI-specific and could potentially be
+   * removed or modified in a further refactor if the server becomes purely API-driven.
+   * For now, we keep it as the core logic in ReadFileTool currently produces it.
+   */
+  returnDisplay: ToolResultDisplay;
+
+  /**
+   * If this property is present, the tool call is considered a failure.
+   */
+  error?: {
+    message: string; // raw error message
+    type?: ToolErrorType; // An optional machine-readable error type (e.g., 'FILE_NOT_FOUND').
+  };
+}
+
+/**
+ * Detects cycles in a JSON schemas due to `$ref`s.
+ * @param schema The root of the JSON schema.
+ * @returns `true` if a cycle is detected, `false` otherwise.
+ */
+export function hasCycleInSchema(schema: object): boolean {
+  function resolveRef(ref: string): object | null {
+    if (!ref.startsWith('#/')) {
+      return null;
+    }
+    const path = ref.substring(2).split('/');
+    let current: unknown = schema;
+    for (const segment of path) {
+      if (
+        typeof current !== 'object' ||
+        current === null ||
+        !Object.prototype.hasOwnProperty.call(current, segment)
+      ) {
+        return null;
+      }
+      current = (current as Record<string, unknown>)[segment];
+    }
+    return current as object;
+  }
+
+  function traverse(
+    node: unknown,
+    visitedRefs: Set<string>,
+    pathRefs: Set<string>,
+  ): boolean {
+    if (typeof node !== 'object' || node === null) {
+      return false;
+    }
+
+    if (Array.isArray(node)) {
+      for (const item of node) {
+        if (traverse(item, visitedRefs, pathRefs)) {
+          return true;
+        }
+      }
+      return false;
+    }
+
+    if ('$ref' in node && typeof node.$ref === 'string') {
+      const ref = node.$ref;
+      if (ref === '#/' || pathRefs.has(ref)) {
+        // A ref to just '#/' is always a cycle.
+        return true; // Cycle detected!
+      }
+      if (visitedRefs.has(ref)) {
+        return false; // Bail early, we have checked this ref before.
+      }
+
+      const resolvedNode = resolveRef(ref);
+      if (resolvedNode) {
+        // Add it to both visited and the current path
+        visitedRefs.add(ref);
+        pathRefs.add(ref);
+        const hasCycle = traverse(resolvedNode, visitedRefs, pathRefs);
+        pathRefs.delete(ref); // Backtrack, leaving it in visited
+        return hasCycle;
+      }
+    }
+
+    // Crawl all the properties of node
+    for (const key in node) {
+      if (Object.prototype.hasOwnProperty.call(node, key)) {
+        if (
+          traverse(
+            (node as Record<string, unknown>)[key],
+            visitedRefs,
+            pathRefs,
+          )
+        ) {
+          return true;
+        }
+      }
+    }
+
+    return false;
+  }
+
+  return traverse(schema, new Set<string>(), new Set<string>());
+}
+
+export type ToolResultDisplay = string | FileDiff | TodoResultDisplay;
+
+export interface FileDiff {
+  fileDiff: string;
+  fileName: string;
+  originalContent: string | null;
+  newContent: string;
+  diffStat?: DiffStat;
+}
+
+export interface DiffStat {
+  ai_removed_lines: number;
+  ai_added_lines: number;
+  user_added_lines: number;
+  user_removed_lines: number;
+}
+
+export interface TodoResultDisplay {
+  type: 'todo_list';
+  todos: Array<{
+    id: string;
+    content: string;
+    status: 'pending' | 'in_progress' | 'completed';
+  }>;
+}
+
+export interface ToolEditConfirmationDetails {
+  type: 'edit';
+  title: string;
+  onConfirm: (
+    outcome: ToolConfirmationOutcome,
+    payload?: ToolConfirmationPayload,
+  ) => Promise<void>;
+  fileName: string;
+  filePath: string;
+  fileDiff: string;
+  originalContent: string | null;
+  newContent: string;
+  isModifying?: boolean;
+  ideConfirmation?: Promise<DiffUpdateResult>;
+}
+
+export interface ToolConfirmationPayload {
+  // used to override `modifiedProposedContent` for modifiable tools in the
+  // inline modify flow
+  newContent: string;
+}
+
+export interface ToolExecuteConfirmationDetails {
+  type: 'exec';
+  title: string;
+  onConfirm: (outcome: ToolConfirmationOutcome) => Promise<void>;
+  command: string;
+  rootCommand: string;
+}
+
+export interface ToolMcpConfirmationDetails {
+  type: 'mcp';
+  title: string;
+  serverName: string;
+  toolName: string;
+  toolDisplayName: string;
+  onConfirm: (outcome: ToolConfirmationOutcome) => Promise<void>;
+}
+
+export interface ToolInfoConfirmationDetails {
+  type: 'info';
+  title: string;
+  onConfirm: (outcome: ToolConfirmationOutcome) => Promise<void>;
+  prompt: string;
+  urls?: string[];
+}
+
+export type ToolCallConfirmationDetails =
+  | ToolEditConfirmationDetails
+  | ToolExecuteConfirmationDetails
+  | ToolMcpConfirmationDetails
+  | ToolInfoConfirmationDetails;
+
+export enum ToolConfirmationOutcome {
+  ProceedOnce = 'proceed_once',
+  ProceedAlways = 'proceed_always',
+  ProceedAlwaysServer = 'proceed_always_server',
+  ProceedAlwaysTool = 'proceed_always_tool',
+  ModifyWithEditor = 'modify_with_editor',
+  Cancel = 'cancel',
+}
+
+export enum Kind {
+  Read = 'read',
+  Edit = 'edit',
+  Delete = 'delete',
+  Move = 'move',
+  Search = 'search',
+  Execute = 'execute',
+  Think = 'think',
+  Fetch = 'fetch',
+  Other = 'other',
+}
+
+export interface ToolLocation {
+  // Absolute path to the file
+  path: string;
+  // Which line (if known)
+  line?: number;
+}

projects/ui/qwen-code/packages/core/src/tools/web-fetch.test.ts

@@ -0,0 +1,107 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { describe, it, expect, vi } from 'vitest';
+import { WebFetchTool } from './web-fetch.js';
+import { Config, ApprovalMode } from '../config/config.js';
+import { ToolConfirmationOutcome } from './tools.js';
+
+describe('WebFetchTool', () => {
+  const mockConfig = {
+    getApprovalMode: vi.fn(),
+    setApprovalMode: vi.fn(),
+    getProxy: vi.fn(),
+  } as unknown as Config;
+
+  describe('shouldConfirmExecute', () => {
+    it('should return confirmation details with the correct prompt and urls', async () => {
+      const tool = new WebFetchTool(mockConfig);
+      const params = {
+        url: 'https://example.com',
+        prompt: 'summarize this page',
+      };
+      const invocation = tool.build(params);
+      const confirmationDetails = await invocation.shouldConfirmExecute(
+        new AbortController().signal,
+      );
+
+      expect(confirmationDetails).toEqual({
+        type: 'info',
+        title: 'Confirm Web Fetch',
+        prompt:
+          'Fetch content from https://example.com and process with: summarize this page',
+        urls: ['https://example.com'],
+        onConfirm: expect.any(Function),
+      });
+    });
+
+    it('should return github urls as-is in confirmation details', async () => {
+      const tool = new WebFetchTool(mockConfig);
+      const params = {
+        url: 'https://github.com/google/gemini-react/blob/main/README.md',
+        prompt: 'summarize the README',
+      };
+      const invocation = tool.build(params);
+      const confirmationDetails = await invocation.shouldConfirmExecute(
+        new AbortController().signal,
+      );
+
+      expect(confirmationDetails).toEqual({
+        type: 'info',
+        title: 'Confirm Web Fetch',
+        prompt:
+          'Fetch content from https://github.com/google/gemini-react/blob/main/README.md and process with: summarize the README',
+        urls: ['https://github.com/google/gemini-react/blob/main/README.md'],
+        onConfirm: expect.any(Function),
+      });
+    });
+
+    it('should return false if approval mode is AUTO_EDIT', async () => {
+      const tool = new WebFetchTool({
+        ...mockConfig,
+        getApprovalMode: () => ApprovalMode.AUTO_EDIT,
+      } as unknown as Config);
+      const params = {
+        url: 'https://example.com',
+        prompt: 'summarize this page',
+      };
+      const invocation = tool.build(params);
+      const confirmationDetails = await invocation.shouldConfirmExecute(
+        new AbortController().signal,
+      );
+
+      expect(confirmationDetails).toBe(false);
+    });
+
+    it('should call setApprovalMode when onConfirm is called with ProceedAlways', async () => {
+      const setApprovalMode = vi.fn();
+      const tool = new WebFetchTool({
+        ...mockConfig,
+        setApprovalMode,
+      } as unknown as Config);
+      const params = {
+        url: 'https://example.com',
+        prompt: 'summarize this page',
+      };
+      const invocation = tool.build(params);
+      const confirmationDetails = await invocation.shouldConfirmExecute(
+        new AbortController().signal,
+      );
+
+      if (
+        confirmationDetails &&
+        typeof confirmationDetails === 'object' &&
+        'onConfirm' in confirmationDetails
+      ) {
+        await confirmationDetails.onConfirm(
+          ToolConfirmationOutcome.ProceedAlways,
+        );
+      }
+
+      expect(setApprovalMode).toHaveBeenCalledWith(ApprovalMode.AUTO_EDIT);
+    });
+  });
+});

projects/ui/qwen-code/packages/core/src/tools/web-fetch.ts

@@ -0,0 +1,236 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import {
+  BaseDeclarativeTool,
+  BaseToolInvocation,
+  Kind,
+  ToolCallConfirmationDetails,
+  ToolConfirmationOutcome,
+  ToolInvocation,
+  ToolResult,
+} from './tools.js';
+
+import { Config, ApprovalMode } from '../config/config.js';
+import { getResponseText } from '../utils/generateContentResponseUtilities.js';
+import { fetchWithTimeout, isPrivateIp } from '../utils/fetch.js';
+import { convert } from 'html-to-text';
+import { ProxyAgent, setGlobalDispatcher } from 'undici';
+
+const URL_FETCH_TIMEOUT_MS = 10000;
+const MAX_CONTENT_LENGTH = 100000;
+
+/**
+ * Parameters for the WebFetch tool
+ */
+export interface WebFetchToolParams {
+  /**
+   * The URL to fetch content from
+   */
+  url: string;
+  /**
+   * The prompt to run on the fetched content
+   */
+  prompt: string;
+}
+
+/**
+ * Implementation of the WebFetch tool invocation logic
+ */
+class WebFetchToolInvocation extends BaseToolInvocation<
+  WebFetchToolParams,
+  ToolResult
+> {
+  constructor(
+    private readonly config: Config,
+    params: WebFetchToolParams,
+  ) {
+    super(params);
+  }
+
+  private async executeDirectFetch(signal: AbortSignal): Promise<ToolResult> {
+    let url = this.params.url;
+
+    // Convert GitHub blob URL to raw URL
+    if (url.includes('github.com') && url.includes('/blob/')) {
+      url = url
+        .replace('github.com', 'raw.githubusercontent.com')
+        .replace('/blob/', '/');
+      console.debug(
+        `[WebFetchTool] Converted GitHub blob URL to raw URL: ${url}`,
+      );
+    }
+
+    try {
+      console.debug(`[WebFetchTool] Fetching content from: ${url}`);
+      const response = await fetchWithTimeout(url, URL_FETCH_TIMEOUT_MS);
+
+      if (!response.ok) {
+        const errorMessage = `Request failed with status code ${response.status} ${response.statusText}`;
+        console.error(`[WebFetchTool] ${errorMessage}`);
+        throw new Error(errorMessage);
+      }
+
+      console.debug(`[WebFetchTool] Successfully fetched content from ${url}`);
+      const html = await response.text();
+      const textContent = convert(html, {
+        wordwrap: false,
+        selectors: [
+          { selector: 'a', options: { ignoreHref: true } },
+          { selector: 'img', format: 'skip' },
+        ],
+      }).substring(0, MAX_CONTENT_LENGTH);
+
+      console.debug(
+        `[WebFetchTool] Converted HTML to text (${textContent.length} characters)`,
+      );
+
+      const geminiClient = this.config.getGeminiClient();
+      const fallbackPrompt = `The user requested the following: "${this.params.prompt}".
+
+I have fetched the content from ${this.params.url}. Please use the following content to answer the user's request.
+
+---
+${textContent}
+---`;
+
+      console.debug(
+        `[WebFetchTool] Processing content with prompt: "${this.params.prompt}"`,
+      );
+
+      const result = await geminiClient.generateContent(
+        [{ role: 'user', parts: [{ text: fallbackPrompt }] }],
+        {},
+        signal,
+      );
+      const resultText = getResponseText(result) || '';
+
+      console.debug(
+        `[WebFetchTool] Successfully processed content from ${this.params.url}`,
+      );
+
+      return {
+        llmContent: resultText,
+        returnDisplay: `Content from ${this.params.url} processed successfully.`,
+      };
+    } catch (e) {
+      const error = e as Error;
+      const errorMessage = `Error during fetch for ${url}: ${error.message}`;
+      console.error(`[WebFetchTool] ${errorMessage}`, error);
+      return {
+        llmContent: `Error: ${errorMessage}`,
+        returnDisplay: `Error: ${errorMessage}`,
+      };
+    }
+  }
+
+  override getDescription(): string {
+    const displayPrompt =
+      this.params.prompt.length > 100
+        ? this.params.prompt.substring(0, 97) + '...'
+        : this.params.prompt;
+    return `Fetching content from ${this.params.url} and processing with prompt: "${displayPrompt}"`;
+  }
+
+  override async shouldConfirmExecute(): Promise<
+    ToolCallConfirmationDetails | false
+  > {
+    if (this.config.getApprovalMode() === ApprovalMode.AUTO_EDIT) {
+      return false;
+    }
+
+    const confirmationDetails: ToolCallConfirmationDetails = {
+      type: 'info',
+      title: `Confirm Web Fetch`,
+      prompt: `Fetch content from ${this.params.url} and process with: ${this.params.prompt}`,
+      urls: [this.params.url],
+      onConfirm: async (outcome: ToolConfirmationOutcome) => {
+        if (outcome === ToolConfirmationOutcome.ProceedAlways) {
+          this.config.setApprovalMode(ApprovalMode.AUTO_EDIT);
+        }
+      },
+    };
+    return confirmationDetails;
+  }
+
+  async execute(signal: AbortSignal): Promise<ToolResult> {
+    // Check if URL is private/localhost
+    const isPrivate = isPrivateIp(this.params.url);
+
+    if (isPrivate) {
+      console.debug(
+        `[WebFetchTool] Private IP detected for ${this.params.url}, using direct fetch`,
+      );
+    } else {
+      console.debug(
+        `[WebFetchTool] Public URL detected for ${this.params.url}, using direct fetch`,
+      );
+    }
+
+    return this.executeDirectFetch(signal);
+  }
+}
+
+/**
+ * Implementation of the WebFetch tool logic
+ */
+export class WebFetchTool extends BaseDeclarativeTool<
+  WebFetchToolParams,
+  ToolResult
+> {
+  static readonly Name: string = 'web_fetch';
+
+  constructor(private readonly config: Config) {
+    super(
+      WebFetchTool.Name,
+      'WebFetch',
+      'Fetches content from a specified URL and processes it using an AI model\n- Takes a URL and a prompt as input\n- Fetches the URL content, converts HTML to markdown\n- Processes the content with the prompt using a small, fast model\n- Returns the model\'s response about the content\n- Use this tool when you need to retrieve and analyze web content\n\nUsage notes:\n  - IMPORTANT: If an MCP-provided web fetch tool is available, prefer using that tool instead of this one, as it may have fewer restrictions. All MCP-provided tools start with "mcp__".\n  - The URL must be a fully-formed valid URL\n  - The prompt should describe what information you want to extract from the page\n  - This tool is read-only and does not modify any files\n  - Results may be summarized if the content is very large\n  - Supports both public and private/localhost URLs using direct fetch',
+      Kind.Fetch,
+      {
+        properties: {
+          url: {
+            description: 'The URL to fetch content from',
+            type: 'string',
+          },
+          prompt: {
+            description: 'The prompt to run on the fetched content',
+            type: 'string',
+          },
+        },
+        required: ['url', 'prompt'],
+        type: 'object',
+      },
+    );
+    const proxy = config.getProxy();
+    if (proxy) {
+      setGlobalDispatcher(new ProxyAgent(proxy as string));
+    }
+  }
+
+  protected override validateToolParamValues(
+    params: WebFetchToolParams,
+  ): string | null {
+    if (!params.url || params.url.trim() === '') {
+      return "The 'url' parameter cannot be empty.";
+    }
+    if (
+      !params.url.startsWith('http://') &&
+      !params.url.startsWith('https://')
+    ) {
+      return "The 'url' must be a valid URL starting with http:// or https://.";
+    }
+    if (!params.prompt || params.prompt.trim() === '') {
+      return "The 'prompt' parameter cannot be empty.";
+    }
+    return null;
+  }
+
+  protected createInvocation(
+    params: WebFetchToolParams,
+  ): ToolInvocation<WebFetchToolParams, ToolResult> {
+    return new WebFetchToolInvocation(this.config, params);
+  }
+}

projects/ui/qwen-code/packages/core/src/tools/web-search.test.ts

@@ -0,0 +1,166 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { WebSearchTool, WebSearchToolParams } from './web-search.js';
+import { Config } from '../config/config.js';
+import { GeminiClient } from '../core/client.js';
+
+// Mock GeminiClient and Config constructor
+vi.mock('../core/client.js');
+vi.mock('../config/config.js');
+
+// Mock global fetch
+const mockFetch = vi.fn();
+global.fetch = mockFetch;
+
+describe('WebSearchTool', () => {
+  const abortSignal = new AbortController().signal;
+  let mockGeminiClient: GeminiClient;
+  let tool: WebSearchTool;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    const mockConfigInstance = {
+      getGeminiClient: () => mockGeminiClient,
+      getProxy: () => undefined,
+      getTavilyApiKey: () => 'test-api-key', // Add the missing method
+    } as unknown as Config;
+    mockGeminiClient = new GeminiClient(mockConfigInstance);
+    tool = new WebSearchTool(mockConfigInstance);
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  describe('build', () => {
+    it('should return an invocation for a valid query', () => {
+      const params: WebSearchToolParams = { query: 'test query' };
+      const invocation = tool.build(params);
+      expect(invocation).toBeDefined();
+      expect(invocation.params).toEqual(params);
+    });
+
+    it('should throw an error for an empty query', () => {
+      const params: WebSearchToolParams = { query: '' };
+      expect(() => tool.build(params)).toThrow(
+        "The 'query' parameter cannot be empty.",
+      );
+    });
+
+    it('should throw an error for a query with only whitespace', () => {
+      const params: WebSearchToolParams = { query: '   ' };
+      expect(() => tool.build(params)).toThrow(
+        "The 'query' parameter cannot be empty.",
+      );
+    });
+  });
+
+  describe('getDescription', () => {
+    it('should return a description of the search', () => {
+      const params: WebSearchToolParams = { query: 'test query' };
+      const invocation = tool.build(params);
+      expect(invocation.getDescription()).toBe(
+        'Searching the web for: "test query"',
+      );
+    });
+  });
+
+  describe('execute', () => {
+    it('should return search results for a successful query', async () => {
+      const params: WebSearchToolParams = { query: 'successful query' };
+
+      // Mock the fetch response
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        json: async () => ({
+          answer: 'Here are your results.',
+          results: [],
+        }),
+      } as Response);
+
+      const invocation = tool.build(params);
+      const result = await invocation.execute(abortSignal);
+
+      expect(result.llmContent).toBe(
+        'Web search results for "successful query":\n\nHere are your results.',
+      );
+      expect(result.returnDisplay).toBe(
+        'Search results for "successful query" returned.',
+      );
+      expect(result.sources).toEqual([]);
+    });
+
+    it('should handle no search results found', async () => {
+      const params: WebSearchToolParams = { query: 'no results query' };
+
+      // Mock the fetch response
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        json: async () => ({
+          answer: '',
+          results: [],
+        }),
+      } as Response);
+
+      const invocation = tool.build(params);
+      const result = await invocation.execute(abortSignal);
+
+      expect(result.llmContent).toBe(
+        'No search results or information found for query: "no results query"',
+      );
+      expect(result.returnDisplay).toBe('No information found.');
+    });
+
+    it('should handle API errors gracefully', async () => {
+      const params: WebSearchToolParams = { query: 'error query' };
+
+      // Mock the fetch to reject
+      mockFetch.mockRejectedValueOnce(new Error('API Failure'));
+
+      const invocation = tool.build(params);
+      const result = await invocation.execute(abortSignal);
+
+      expect(result.llmContent).toContain('Error:');
+      expect(result.llmContent).toContain('API Failure');
+      expect(result.returnDisplay).toBe('Error performing web search.');
+    });
+
+    it('should correctly format results with sources', async () => {
+      const params: WebSearchToolParams = { query: 'grounding query' };
+
+      // Mock the fetch response
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        json: async () => ({
+          answer: 'This is a test response.',
+          results: [
+            { title: 'Example Site', url: 'https://example.com' },
+            { title: 'Google', url: 'https://google.com' },
+          ],
+        }),
+      } as Response);
+
+      const invocation = tool.build(params);
+      const result = await invocation.execute(abortSignal);
+
+      const expectedLlmContent = `Web search results for "grounding query":
+
+This is a test response.
+
+Sources:
+[1] Example Site (https://example.com)
+[2] Google (https://google.com)`;
+
+      expect(result.llmContent).toBe(expectedLlmContent);
+      expect(result.returnDisplay).toBe(
+        'Search results for "grounding query" returned.',
+      );
+      expect(result.sources).toHaveLength(2);
+    });
+  });
+});

projects/ui/qwen-code/packages/core/src/tools/web-search.ts

@@ -0,0 +1,195 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import {
+  BaseDeclarativeTool,
+  BaseToolInvocation,
+  Kind,
+  ToolInvocation,
+  ToolResult,
+} from './tools.js';
+
+import { getErrorMessage } from '../utils/errors.js';
+import { Config } from '../config/config.js';
+
+interface TavilyResultItem {
+  title: string;
+  url: string;
+  content?: string;
+  score?: number;
+  published_date?: string;
+}
+
+interface TavilySearchResponse {
+  query: string;
+  answer?: string;
+  results: TavilyResultItem[];
+}
+
+/**
+ * Parameters for the WebSearchTool.
+ */
+export interface WebSearchToolParams {
+  /**
+   * The search query.
+   */
+  query: string;
+}
+
+/**
+ * Extends ToolResult to include sources for web search.
+ */
+export interface WebSearchToolResult extends ToolResult {
+  sources?: Array<{ title: string; url: string }>;
+}
+
+class WebSearchToolInvocation extends BaseToolInvocation<
+  WebSearchToolParams,
+  WebSearchToolResult
+> {
+  constructor(
+    private readonly config: Config,
+    params: WebSearchToolParams,
+  ) {
+    super(params);
+  }
+
+  override getDescription(): string {
+    return `Searching the web for: "${this.params.query}"`;
+  }
+
+  async execute(signal: AbortSignal): Promise<WebSearchToolResult> {
+    const apiKey =
+      this.config.getTavilyApiKey() || process.env['TAVILY_API_KEY'];
+    if (!apiKey) {
+      return {
+        llmContent:
+          'Web search is disabled because TAVILY_API_KEY is not configured. Please set it in your settings.json, .env file, or via --tavily-api-key command line argument to enable web search.',
+        returnDisplay:
+          'Web search disabled. Configure TAVILY_API_KEY to enable Tavily search.',
+      };
+    }
+
+    try {
+      const response = await fetch('https://api.tavily.com/search', {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({
+          api_key: apiKey,
+          query: this.params.query,
+          search_depth: 'advanced',
+          max_results: 5,
+          include_answer: true,
+        }),
+        signal,
+      });
+
+      if (!response.ok) {
+        const text = await response.text().catch(() => '');
+        throw new Error(
+          `Tavily API error: ${response.status} ${response.statusText}${text ? ` - ${text}` : ''}`,
+        );
+      }
+
+      const data = (await response.json()) as TavilySearchResponse;
+
+      const sources = (data.results || []).map((r) => ({
+        title: r.title,
+        url: r.url,
+      }));
+
+      const sourceListFormatted = sources.map(
+        (s, i) => `[${i + 1}] ${s.title || 'Untitled'} (${s.url})`,
+      );
+
+      let content = data.answer?.trim() || '';
+      if (!content) {
+        // Fallback: build a concise summary from top results
+        content = sources
+          .slice(0, 3)
+          .map((s, i) => `${i + 1}. ${s.title} - ${s.url}`)
+          .join('\n');
+      }
+
+      if (sourceListFormatted.length > 0) {
+        content += `\n\nSources:\n${sourceListFormatted.join('\n')}`;
+      }
+
+      if (!content.trim()) {
+        return {
+          llmContent: `No search results or information found for query: "${this.params.query}"`,
+          returnDisplay: 'No information found.',
+        };
+      }
+
+      return {
+        llmContent: `Web search results for "${this.params.query}":\n\n${content}`,
+        returnDisplay: `Search results for "${this.params.query}" returned.`,
+        sources,
+      };
+    } catch (error: unknown) {
+      const errorMessage = `Error during web search for query "${this.params.query}": ${getErrorMessage(
+        error,
+      )}`;
+      console.error(errorMessage, error);
+      return {
+        llmContent: `Error: ${errorMessage}`,
+        returnDisplay: `Error performing web search.`,
+      };
+    }
+  }
+}
+
+/**
+ * A tool to perform web searches using Google Search via the Gemini API.
+ */
+export class WebSearchTool extends BaseDeclarativeTool<
+  WebSearchToolParams,
+  WebSearchToolResult
+> {
+  static readonly Name: string = 'web_search';
+
+  constructor(private readonly config: Config) {
+    super(
+      WebSearchTool.Name,
+      'TavilySearch',
+      'Performs a web search using the Tavily API and returns a concise answer with sources. Requires the TAVILY_API_KEY environment variable.',
+      Kind.Search,
+      {
+        type: 'object',
+        properties: {
+          query: {
+            type: 'string',
+            description: 'The search query to find information on the web.',
+          },
+        },
+        required: ['query'],
+      },
+    );
+  }
+
+  /**
+   * Validates the parameters for the WebSearchTool.
+   * @param params The parameters to validate
+   * @returns An error message string if validation fails, null if valid
+   */
+  protected override validateToolParamValues(
+    params: WebSearchToolParams,
+  ): string | null {
+    if (!params.query || params.query.trim() === '') {
+      return "The 'query' parameter cannot be empty.";
+    }
+    return null;
+  }
+
+  protected createInvocation(
+    params: WebSearchToolParams,
+  ): ToolInvocation<WebSearchToolParams, WebSearchToolResult> {
+    return new WebSearchToolInvocation(this.config, params);
+  }
+}

projects/ui/qwen-code/packages/core/src/tools/write-file.test.ts

@@ -0,0 +1,783 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import {
+  describe,
+  it,
+  expect,
+  beforeEach,
+  afterEach,
+  vi,
+  type Mocked,
+} from 'vitest';
+import {
+  getCorrectedFileContent,
+  WriteFileTool,
+  WriteFileToolParams,
+} from './write-file.js';
+import { ToolErrorType } from './tool-error.js';
+import {
+  FileDiff,
+  ToolConfirmationOutcome,
+  ToolEditConfirmationDetails,
+} from './tools.js';
+import { type EditToolParams } from './edit.js';
+import { ApprovalMode, Config } from '../config/config.js';
+import { ToolRegistry } from './tool-registry.js';
+import path from 'path';
+import fs from 'fs';
+import os from 'os';
+import { GeminiClient } from '../core/client.js';
+import {
+  ensureCorrectEdit,
+  ensureCorrectFileContent,
+  CorrectedEditResult,
+} from '../utils/editCorrector.js';
+import { createMockWorkspaceContext } from '../test-utils/mockWorkspaceContext.js';
+import { StandardFileSystemService } from '../services/fileSystemService.js';
+
+const rootDir = path.resolve(os.tmpdir(), 'qwen-code-test-root');
+
+// --- MOCKS ---
+vi.mock('../core/client.js');
+vi.mock('../utils/editCorrector.js');
+
+let mockGeminiClientInstance: Mocked<GeminiClient>;
+const mockEnsureCorrectEdit = vi.fn<typeof ensureCorrectEdit>();
+const mockEnsureCorrectFileContent = vi.fn<typeof ensureCorrectFileContent>();
+
+// Wire up the mocked functions to be used by the actual module imports
+vi.mocked(ensureCorrectEdit).mockImplementation(mockEnsureCorrectEdit);
+vi.mocked(ensureCorrectFileContent).mockImplementation(
+  mockEnsureCorrectFileContent,
+);
+
+// Mock Config
+const fsService = new StandardFileSystemService();
+const mockConfigInternal = {
+  getTargetDir: () => rootDir,
+  getApprovalMode: vi.fn(() => ApprovalMode.DEFAULT),
+  setApprovalMode: vi.fn(),
+  getGeminiClient: vi.fn(), // Initialize as a plain mock function
+  getFileSystemService: () => fsService,
+  getIdeClient: vi.fn(),
+  getIdeMode: vi.fn(() => false),
+  getWorkspaceContext: () => createMockWorkspaceContext(rootDir),
+  getApiKey: () => 'test-key',
+  getModel: () => 'test-model',
+  getSandbox: () => false,
+  getDebugMode: () => false,
+  getQuestion: () => undefined,
+  getFullContext: () => false,
+  getToolDiscoveryCommand: () => undefined,
+  getToolCallCommand: () => undefined,
+  getMcpServerCommand: () => undefined,
+  getMcpServers: () => undefined,
+  getUserAgent: () => 'test-agent',
+  getUserMemory: () => '',
+  setUserMemory: vi.fn(),
+  getGeminiMdFileCount: () => 0,
+  setGeminiMdFileCount: vi.fn(),
+  getToolRegistry: () =>
+    ({
+      registerTool: vi.fn(),
+      discoverTools: vi.fn(),
+    }) as unknown as ToolRegistry,
+};
+const mockConfig = mockConfigInternal as unknown as Config;
+// --- END MOCKS ---
+
+describe('WriteFileTool', () => {
+  let tool: WriteFileTool;
+  let tempDir: string;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    // Create a unique temporary directory for files created outside the root
+    tempDir = fs.mkdtempSync(
+      path.join(os.tmpdir(), 'write-file-test-external-'),
+    );
+    // Ensure the rootDir for the tool exists
+    if (!fs.existsSync(rootDir)) {
+      fs.mkdirSync(rootDir, { recursive: true });
+    }
+
+    // Setup GeminiClient mock
+    mockGeminiClientInstance = new (vi.mocked(GeminiClient))(
+      mockConfig,
+    ) as Mocked<GeminiClient>;
+    vi.mocked(GeminiClient).mockImplementation(() => mockGeminiClientInstance);
+
+    vi.mocked(ensureCorrectEdit).mockImplementation(mockEnsureCorrectEdit);
+    vi.mocked(ensureCorrectFileContent).mockImplementation(
+      mockEnsureCorrectFileContent,
+    );
+
+    // Now that mockGeminiClientInstance is initialized, set the mock implementation for getGeminiClient
+    mockConfigInternal.getGeminiClient.mockReturnValue(
+      mockGeminiClientInstance,
+    );
+    mockConfigInternal.getIdeClient.mockReturnValue({
+      openDiff: vi.fn(),
+      closeDiff: vi.fn(),
+      getIdeContext: vi.fn(),
+      subscribeToIdeContext: vi.fn(),
+      isCodeTrackerEnabled: vi.fn(),
+      getTrackedCode: vi.fn(),
+    });
+
+    tool = new WriteFileTool(mockConfig);
+
+    // Reset mocks before each test
+    mockConfigInternal.getApprovalMode.mockReturnValue(ApprovalMode.DEFAULT);
+    mockConfigInternal.setApprovalMode.mockClear();
+    mockEnsureCorrectEdit.mockReset();
+    mockEnsureCorrectFileContent.mockReset();
+
+    // Default mock implementations that return valid structures
+    mockEnsureCorrectEdit.mockImplementation(
+      async (
+        filePath: string,
+        _currentContent: string,
+        params: EditToolParams,
+        _client: GeminiClient,
+        signal?: AbortSignal, // Make AbortSignal optional to match usage
+      ): Promise<CorrectedEditResult> => {
+        if (signal?.aborted) {
+          return Promise.reject(new Error('Aborted'));
+        }
+        return Promise.resolve({
+          params: { ...params, new_string: params.new_string ?? '' },
+          occurrences: 1,
+        });
+      },
+    );
+    mockEnsureCorrectFileContent.mockImplementation(
+      async (
+        content: string,
+        _client: GeminiClient,
+        signal?: AbortSignal,
+      ): Promise<string> => {
+        // Make AbortSignal optional
+        if (signal?.aborted) {
+          return Promise.reject(new Error('Aborted'));
+        }
+        return Promise.resolve(content ?? '');
+      },
+    );
+  });
+
+  afterEach(() => {
+    // Clean up the temporary directories
+    if (fs.existsSync(tempDir)) {
+      fs.rmSync(tempDir, { recursive: true, force: true });
+    }
+    if (fs.existsSync(rootDir)) {
+      fs.rmSync(rootDir, { recursive: true, force: true });
+    }
+    vi.clearAllMocks();
+  });
+
+  describe('build', () => {
+    it('should return an invocation for a valid absolute path within root', () => {
+      const params = {
+        file_path: path.join(rootDir, 'test.txt'),
+        content: 'hello',
+      };
+      const invocation = tool.build(params);
+      expect(invocation).toBeDefined();
+      expect(invocation.params).toEqual(params);
+    });
+
+    it('should throw an error for a relative path', () => {
+      const params = { file_path: 'test.txt', content: 'hello' };
+      expect(() => tool.build(params)).toThrow(/File path must be absolute/);
+    });
+
+    it('should throw an error for a path outside root', () => {
+      const outsidePath = path.resolve(tempDir, 'outside-root.txt');
+      const params = {
+        file_path: outsidePath,
+        content: 'hello',
+      };
+      expect(() => tool.build(params)).toThrow(
+        /File path must be within one of the workspace directories/,
+      );
+    });
+
+    it('should throw an error if path is a directory', () => {
+      const dirAsFilePath = path.join(rootDir, 'a_directory');
+      fs.mkdirSync(dirAsFilePath);
+      const params = {
+        file_path: dirAsFilePath,
+        content: 'hello',
+      };
+      expect(() => tool.build(params)).toThrow(
+        `Path is a directory, not a file: ${dirAsFilePath}`,
+      );
+    });
+
+    it('should throw an error if the content is null', () => {
+      const dirAsFilePath = path.join(rootDir, 'a_directory');
+      fs.mkdirSync(dirAsFilePath);
+      const params = {
+        file_path: dirAsFilePath,
+        content: null,
+      } as unknown as WriteFileToolParams; // Intentionally non-conforming
+      expect(() => tool.build(params)).toThrow('params/content must be string');
+    });
+
+    it('should throw error if the file_path is empty', () => {
+      const dirAsFilePath = path.join(rootDir, 'a_directory');
+      fs.mkdirSync(dirAsFilePath);
+      const params = {
+        file_path: '',
+        content: '',
+      };
+      expect(() => tool.build(params)).toThrow(`Missing or empty "file_path"`);
+    });
+  });
+
+  describe('getCorrectedFileContent', () => {
+    it('should call ensureCorrectFileContent for a new file', async () => {
+      const filePath = path.join(rootDir, 'new_corrected_file.txt');
+      const proposedContent = 'Proposed new content.';
+      const correctedContent = 'Corrected new content.';
+      const abortSignal = new AbortController().signal;
+      // Ensure the mock is set for this specific test case if needed, or rely on beforeEach
+      mockEnsureCorrectFileContent.mockResolvedValue(correctedContent);
+
+      const result = await getCorrectedFileContent(
+        mockConfig,
+        filePath,
+        proposedContent,
+        abortSignal,
+      );
+
+      expect(mockEnsureCorrectFileContent).toHaveBeenCalledWith(
+        proposedContent,
+        mockGeminiClientInstance,
+        abortSignal,
+      );
+      expect(mockEnsureCorrectEdit).not.toHaveBeenCalled();
+      expect(result.correctedContent).toBe(correctedContent);
+      expect(result.originalContent).toBe('');
+      expect(result.fileExists).toBe(false);
+      expect(result.error).toBeUndefined();
+    });
+
+    it('should call ensureCorrectEdit for an existing file', async () => {
+      const filePath = path.join(rootDir, 'existing_corrected_file.txt');
+      const originalContent = 'Original existing content.';
+      const proposedContent = 'Proposed replacement content.';
+      const correctedProposedContent = 'Corrected replacement content.';
+      const abortSignal = new AbortController().signal;
+      fs.writeFileSync(filePath, originalContent, 'utf8');
+
+      // Ensure this mock is active and returns the correct structure
+      mockEnsureCorrectEdit.mockResolvedValue({
+        params: {
+          file_path: filePath,
+          old_string: originalContent,
+          new_string: correctedProposedContent,
+        },
+        occurrences: 1,
+      } as CorrectedEditResult);
+
+      const result = await getCorrectedFileContent(
+        mockConfig,
+        filePath,
+        proposedContent,
+        abortSignal,
+      );
+
+      expect(mockEnsureCorrectEdit).toHaveBeenCalledWith(
+        filePath,
+        originalContent,
+        {
+          old_string: originalContent,
+          new_string: proposedContent,
+          file_path: filePath,
+        },
+        mockGeminiClientInstance,
+        abortSignal,
+      );
+      expect(mockEnsureCorrectFileContent).not.toHaveBeenCalled();
+      expect(result.correctedContent).toBe(correctedProposedContent);
+      expect(result.originalContent).toBe(originalContent);
+      expect(result.fileExists).toBe(true);
+      expect(result.error).toBeUndefined();
+    });
+
+    it('should return error if reading an existing file fails (e.g. permissions)', async () => {
+      const filePath = path.join(rootDir, 'unreadable_file.txt');
+      const proposedContent = 'some content';
+      const abortSignal = new AbortController().signal;
+      fs.writeFileSync(filePath, 'content', { mode: 0o000 });
+
+      const readError = new Error('Permission denied');
+      vi.spyOn(fsService, 'readTextFile').mockImplementationOnce(() =>
+        Promise.reject(readError),
+      );
+
+      const result = await getCorrectedFileContent(
+        mockConfig,
+        filePath,
+        proposedContent,
+        abortSignal,
+      );
+
+      expect(fsService.readTextFile).toHaveBeenCalledWith(filePath);
+      expect(mockEnsureCorrectEdit).not.toHaveBeenCalled();
+      expect(mockEnsureCorrectFileContent).not.toHaveBeenCalled();
+      expect(result.correctedContent).toBe(proposedContent);
+      expect(result.originalContent).toBe('');
+      expect(result.fileExists).toBe(true);
+      expect(result.error).toEqual({
+        message: 'Permission denied',
+        code: undefined,
+      });
+
+      fs.chmodSync(filePath, 0o600);
+    });
+  });
+
+  describe('shouldConfirmExecute', () => {
+    const abortSignal = new AbortController().signal;
+
+    it('should return false if _getCorrectedFileContent returns an error', async () => {
+      const filePath = path.join(rootDir, 'confirm_error_file.txt');
+      const params = { file_path: filePath, content: 'test content' };
+      fs.writeFileSync(filePath, 'original', { mode: 0o000 });
+
+      const readError = new Error('Simulated read error for confirmation');
+      vi.spyOn(fsService, 'readTextFile').mockImplementationOnce(() =>
+        Promise.reject(readError),
+      );
+
+      const invocation = tool.build(params);
+      const confirmation = await invocation.shouldConfirmExecute(abortSignal);
+      expect(confirmation).toBe(false);
+
+      fs.chmodSync(filePath, 0o600);
+    });
+
+    it('should request confirmation with diff for a new file (with corrected content)', async () => {
+      const filePath = path.join(rootDir, 'confirm_new_file.txt');
+      const proposedContent = 'Proposed new content for confirmation.';
+      const correctedContent = 'Corrected new content for confirmation.';
+      mockEnsureCorrectFileContent.mockResolvedValue(correctedContent); // Ensure this mock is active
+
+      const params = { file_path: filePath, content: proposedContent };
+      const invocation = tool.build(params);
+      const confirmation = (await invocation.shouldConfirmExecute(
+        abortSignal,
+      )) as ToolEditConfirmationDetails;
+
+      expect(mockEnsureCorrectFileContent).toHaveBeenCalledWith(
+        proposedContent,
+        mockGeminiClientInstance,
+        abortSignal,
+      );
+      expect(confirmation).toEqual(
+        expect.objectContaining({
+          title: `Confirm Write: ${path.basename(filePath)}`,
+          fileName: 'confirm_new_file.txt',
+          fileDiff: expect.stringContaining(correctedContent),
+        }),
+      );
+      expect(confirmation.fileDiff).toMatch(
+        /--- confirm_new_file.txt\tCurrent/,
+      );
+      expect(confirmation.fileDiff).toMatch(
+        /\+\+\+ confirm_new_file.txt\tProposed/,
+      );
+    });
+
+    it('should request confirmation with diff for an existing file (with corrected content)', async () => {
+      const filePath = path.join(rootDir, 'confirm_existing_file.txt');
+      const originalContent = 'Original content for confirmation.';
+      const proposedContent = 'Proposed replacement for confirmation.';
+      const correctedProposedContent =
+        'Corrected replacement for confirmation.';
+      fs.writeFileSync(filePath, originalContent, 'utf8');
+
+      mockEnsureCorrectEdit.mockResolvedValue({
+        params: {
+          file_path: filePath,
+          old_string: originalContent,
+          new_string: correctedProposedContent,
+        },
+        occurrences: 1,
+      });
+
+      const params = { file_path: filePath, content: proposedContent };
+      const invocation = tool.build(params);
+      const confirmation = (await invocation.shouldConfirmExecute(
+        abortSignal,
+      )) as ToolEditConfirmationDetails;
+
+      expect(mockEnsureCorrectEdit).toHaveBeenCalledWith(
+        filePath,
+        originalContent,
+        {
+          old_string: originalContent,
+          new_string: proposedContent,
+          file_path: filePath,
+        },
+        mockGeminiClientInstance,
+        abortSignal,
+      );
+      expect(confirmation).toEqual(
+        expect.objectContaining({
+          title: `Confirm Write: ${path.basename(filePath)}`,
+          fileName: 'confirm_existing_file.txt',
+          fileDiff: expect.stringContaining(correctedProposedContent),
+        }),
+      );
+      expect(confirmation.fileDiff).toMatch(
+        originalContent.replace(/[.*+?^${}()|[\\]\\]/g, '\\$&'),
+      );
+    });
+  });
+
+  describe('execute', () => {
+    const abortSignal = new AbortController().signal;
+
+    it('should return error if _getCorrectedFileContent returns an error during execute', async () => {
+      const filePath = path.join(rootDir, 'execute_error_file.txt');
+      const params = { file_path: filePath, content: 'test content' };
+      fs.writeFileSync(filePath, 'original', { mode: 0o000 });
+
+      vi.spyOn(fsService, 'readTextFile').mockImplementationOnce(() => {
+        const readError = new Error('Simulated read error for execute');
+        return Promise.reject(readError);
+      });
+
+      const invocation = tool.build(params);
+      const result = await invocation.execute(abortSignal);
+      expect(result.llmContent).toContain('Error checking existing file');
+      expect(result.returnDisplay).toMatch(
+        /Error checking existing file: Simulated read error for execute/,
+      );
+      expect(result.error).toEqual({
+        message:
+          'Error checking existing file: Simulated read error for execute',
+        type: ToolErrorType.FILE_WRITE_FAILURE,
+      });
+
+      fs.chmodSync(filePath, 0o600);
+    });
+
+    it('should write a new file with corrected content and return diff', async () => {
+      const filePath = path.join(rootDir, 'execute_new_corrected_file.txt');
+      const proposedContent = 'Proposed new content for execute.';
+      const correctedContent = 'Corrected new content for execute.';
+      mockEnsureCorrectFileContent.mockResolvedValue(correctedContent);
+
+      const params = { file_path: filePath, content: proposedContent };
+      const invocation = tool.build(params);
+
+      const confirmDetails = await invocation.shouldConfirmExecute(abortSignal);
+      if (
+        typeof confirmDetails === 'object' &&
+        'onConfirm' in confirmDetails &&
+        confirmDetails.onConfirm
+      ) {
+        await confirmDetails.onConfirm(ToolConfirmationOutcome.ProceedOnce);
+      }
+
+      const result = await invocation.execute(abortSignal);
+
+      expect(mockEnsureCorrectFileContent).toHaveBeenCalledWith(
+        proposedContent,
+        mockGeminiClientInstance,
+        abortSignal,
+      );
+      expect(result.llmContent).toMatch(
+        /Successfully created and wrote to new file/,
+      );
+      expect(fs.existsSync(filePath)).toBe(true);
+      const writtenContent = await fsService.readTextFile(filePath);
+      expect(writtenContent).toBe(correctedContent);
+      const display = result.returnDisplay as FileDiff;
+      expect(display.fileName).toBe('execute_new_corrected_file.txt');
+      expect(display.fileDiff).toMatch(
+        /--- execute_new_corrected_file.txt\tOriginal/,
+      );
+      expect(display.fileDiff).toMatch(
+        /\+\+\+ execute_new_corrected_file.txt\tWritten/,
+      );
+      expect(display.fileDiff).toMatch(
+        correctedContent.replace(/[.*+?^${}()|[\\]\\]/g, '\\$&'),
+      );
+    });
+
+    it('should overwrite an existing file with corrected content and return diff', async () => {
+      const filePath = path.join(
+        rootDir,
+        'execute_existing_corrected_file.txt',
+      );
+      const initialContent = 'Initial content for execute.';
+      const proposedContent = 'Proposed overwrite for execute.';
+      const correctedProposedContent = 'Corrected overwrite for execute.';
+      fs.writeFileSync(filePath, initialContent, 'utf8');
+
+      mockEnsureCorrectEdit.mockResolvedValue({
+        params: {
+          file_path: filePath,
+          old_string: initialContent,
+          new_string: correctedProposedContent,
+        },
+        occurrences: 1,
+      });
+
+      const params = { file_path: filePath, content: proposedContent };
+      const invocation = tool.build(params);
+
+      const confirmDetails = await invocation.shouldConfirmExecute(abortSignal);
+      if (
+        typeof confirmDetails === 'object' &&
+        'onConfirm' in confirmDetails &&
+        confirmDetails.onConfirm
+      ) {
+        await confirmDetails.onConfirm(ToolConfirmationOutcome.ProceedOnce);
+      }
+
+      const result = await invocation.execute(abortSignal);
+
+      expect(mockEnsureCorrectEdit).toHaveBeenCalledWith(
+        filePath,
+        initialContent,
+        {
+          old_string: initialContent,
+          new_string: proposedContent,
+          file_path: filePath,
+        },
+        mockGeminiClientInstance,
+        abortSignal,
+      );
+      expect(result.llmContent).toMatch(/Successfully overwrote file/);
+      const writtenContent = await fsService.readTextFile(filePath);
+      expect(writtenContent).toBe(correctedProposedContent);
+      const display = result.returnDisplay as FileDiff;
+      expect(display.fileName).toBe('execute_existing_corrected_file.txt');
+      expect(display.fileDiff).toMatch(
+        initialContent.replace(/[.*+?^${}()|[\\]\\]/g, '\\$&'),
+      );
+      expect(display.fileDiff).toMatch(
+        correctedProposedContent.replace(/[.*+?^${}()|[\\]\\]/g, '\\$&'),
+      );
+    });
+
+    it('should create directory if it does not exist', async () => {
+      const dirPath = path.join(rootDir, 'new_dir_for_write');
+      const filePath = path.join(dirPath, 'file_in_new_dir.txt');
+      const content = 'Content in new directory';
+      mockEnsureCorrectFileContent.mockResolvedValue(content); // Ensure this mock is active
+
+      const params = { file_path: filePath, content };
+      const invocation = tool.build(params);
+      // Simulate confirmation if your logic requires it before execute, or remove if not needed for this path
+      const confirmDetails = await invocation.shouldConfirmExecute(abortSignal);
+      if (
+        typeof confirmDetails === 'object' &&
+        'onConfirm' in confirmDetails &&
+        confirmDetails.onConfirm
+      ) {
+        await confirmDetails.onConfirm(ToolConfirmationOutcome.ProceedOnce);
+      }
+
+      await invocation.execute(abortSignal);
+
+      expect(fs.existsSync(dirPath)).toBe(true);
+      expect(fs.statSync(dirPath).isDirectory()).toBe(true);
+      expect(fs.existsSync(filePath)).toBe(true);
+      expect(fs.readFileSync(filePath, 'utf8')).toBe(content);
+    });
+
+    it('should include modification message when proposed content is modified', async () => {
+      const filePath = path.join(rootDir, 'new_file_modified.txt');
+      const content = 'New file content modified by user';
+      mockEnsureCorrectFileContent.mockResolvedValue(content);
+
+      const params = {
+        file_path: filePath,
+        content,
+        modified_by_user: true,
+      };
+      const invocation = tool.build(params);
+      const result = await invocation.execute(abortSignal);
+
+      expect(result.llmContent).toMatch(/User modified the `content`/);
+    });
+
+    it('should not include modification message when proposed content is not modified', async () => {
+      const filePath = path.join(rootDir, 'new_file_unmodified.txt');
+      const content = 'New file content not modified';
+      mockEnsureCorrectFileContent.mockResolvedValue(content);
+
+      const params = {
+        file_path: filePath,
+        content,
+        modified_by_user: false,
+      };
+      const invocation = tool.build(params);
+      const result = await invocation.execute(abortSignal);
+
+      expect(result.llmContent).not.toMatch(/User modified the `content`/);
+    });
+
+    it('should not include modification message when modified_by_user is not provided', async () => {
+      const filePath = path.join(rootDir, 'new_file_unmodified.txt');
+      const content = 'New file content not modified';
+      mockEnsureCorrectFileContent.mockResolvedValue(content);
+
+      const params = {
+        file_path: filePath,
+        content,
+      };
+      const invocation = tool.build(params);
+      const result = await invocation.execute(abortSignal);
+
+      expect(result.llmContent).not.toMatch(/User modified the `content`/);
+    });
+  });
+
+  describe('workspace boundary validation', () => {
+    it('should validate paths are within workspace root', () => {
+      const params = {
+        file_path: path.join(rootDir, 'file.txt'),
+        content: 'test content',
+      };
+      expect(() => tool.build(params)).not.toThrow();
+    });
+
+    it('should reject paths outside workspace root', () => {
+      const params = {
+        file_path: '/etc/passwd',
+        content: 'malicious',
+      };
+      expect(() => tool.build(params)).toThrow(
+        /File path must be within one of the workspace directories/,
+      );
+    });
+  });
+
+  describe('specific error types for write failures', () => {
+    const abortSignal = new AbortController().signal;
+
+    it('should return PERMISSION_DENIED error when write fails with EACCES', async () => {
+      const filePath = path.join(rootDir, 'permission_denied_file.txt');
+      const content = 'test content';
+
+      // Mock FileSystemService writeTextFile to throw EACCES error
+      vi.spyOn(fsService, 'writeTextFile').mockImplementationOnce(() => {
+        const error = new Error('Permission denied') as NodeJS.ErrnoException;
+        error.code = 'EACCES';
+        return Promise.reject(error);
+      });
+
+      const params = { file_path: filePath, content };
+      const invocation = tool.build(params);
+      const result = await invocation.execute(abortSignal);
+
+      expect(result.error?.type).toBe(ToolErrorType.PERMISSION_DENIED);
+      expect(result.llmContent).toContain(
+        `Permission denied writing to file: ${filePath} (EACCES)`,
+      );
+      expect(result.returnDisplay).toContain(
+        `Permission denied writing to file: ${filePath} (EACCES)`,
+      );
+    });
+
+    it('should return NO_SPACE_LEFT error when write fails with ENOSPC', async () => {
+      const filePath = path.join(rootDir, 'no_space_file.txt');
+      const content = 'test content';
+
+      // Mock FileSystemService writeTextFile to throw ENOSPC error
+      vi.spyOn(fsService, 'writeTextFile').mockImplementationOnce(() => {
+        const error = new Error(
+          'No space left on device',
+        ) as NodeJS.ErrnoException;
+        error.code = 'ENOSPC';
+        return Promise.reject(error);
+      });
+
+      const params = { file_path: filePath, content };
+      const invocation = tool.build(params);
+      const result = await invocation.execute(abortSignal);
+
+      expect(result.error?.type).toBe(ToolErrorType.NO_SPACE_LEFT);
+      expect(result.llmContent).toContain(
+        `No space left on device: ${filePath} (ENOSPC)`,
+      );
+      expect(result.returnDisplay).toContain(
+        `No space left on device: ${filePath} (ENOSPC)`,
+      );
+    });
+
+    it('should return TARGET_IS_DIRECTORY error when write fails with EISDIR', async () => {
+      const dirPath = path.join(rootDir, 'test_directory');
+      const content = 'test content';
+
+      // Mock fs.existsSync to return false to bypass validation
+      const originalExistsSync = fs.existsSync;
+      vi.spyOn(fs, 'existsSync').mockImplementation((path) => {
+        if (path === dirPath) {
+          return false; // Pretend directory doesn't exist to bypass validation
+        }
+        return originalExistsSync(path as string);
+      });
+
+      // Mock FileSystemService writeTextFile to throw EISDIR error
+      vi.spyOn(fsService, 'writeTextFile').mockImplementationOnce(() => {
+        const error = new Error('Is a directory') as NodeJS.ErrnoException;
+        error.code = 'EISDIR';
+        return Promise.reject(error);
+      });
+
+      const params = { file_path: dirPath, content };
+      const invocation = tool.build(params);
+      const result = await invocation.execute(abortSignal);
+
+      expect(result.error?.type).toBe(ToolErrorType.TARGET_IS_DIRECTORY);
+      expect(result.llmContent).toContain(
+        `Target is a directory, not a file: ${dirPath} (EISDIR)`,
+      );
+      expect(result.returnDisplay).toContain(
+        `Target is a directory, not a file: ${dirPath} (EISDIR)`,
+      );
+
+      vi.spyOn(fs, 'existsSync').mockImplementation(originalExistsSync);
+    });
+
+    it('should return FILE_WRITE_FAILURE for generic write errors', async () => {
+      const filePath = path.join(rootDir, 'generic_error_file.txt');
+      const content = 'test content';
+
+      // Ensure fs.existsSync is not mocked for this test
+      vi.restoreAllMocks();
+
+      // Mock FileSystemService writeTextFile to throw generic error
+      vi.spyOn(fsService, 'writeTextFile').mockImplementationOnce(() =>
+        Promise.reject(new Error('Generic write error')),
+      );
+
+      const params = { file_path: filePath, content };
+      const invocation = tool.build(params);
+      const result = await invocation.execute(abortSignal);
+
+      expect(result.error?.type).toBe(ToolErrorType.FILE_WRITE_FAILURE);
+      expect(result.llmContent).toContain(
+        'Error writing to file: Generic write error',
+      );
+      expect(result.returnDisplay).toContain(
+        'Error writing to file: Generic write error',
+      );
+    });
+  });
+});

projects/ui/qwen-code/packages/core/src/tools/write-file.ts

@@ -0,0 +1,500 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import fs from 'fs';
+import path from 'path';
+import * as Diff from 'diff';
+import { Config, ApprovalMode } from '../config/config.js';
+import {
+  BaseDeclarativeTool,
+  BaseToolInvocation,
+  FileDiff,
+  Kind,
+  ToolCallConfirmationDetails,
+  ToolConfirmationOutcome,
+  ToolEditConfirmationDetails,
+  ToolInvocation,
+  ToolLocation,
+  ToolResult,
+} from './tools.js';
+import { ToolErrorType } from './tool-error.js';
+import { makeRelative, shortenPath } from '../utils/paths.js';
+import { getErrorMessage, isNodeError } from '../utils/errors.js';
+import {
+  ensureCorrectEdit,
+  ensureCorrectFileContent,
+} from '../utils/editCorrector.js';
+import { DEFAULT_DIFF_OPTIONS, getDiffStat } from './diffOptions.js';
+import { ModifiableDeclarativeTool, ModifyContext } from './modifiable-tool.js';
+import { getSpecificMimeType } from '../utils/fileUtils.js';
+import {
+  recordFileOperationMetric,
+  FileOperation,
+} from '../telemetry/metrics.js';
+import { IDEConnectionStatus } from '../ide/ide-client.js';
+
+/**
+ * Parameters for the WriteFile tool
+ */
+export interface WriteFileToolParams {
+  /**
+   * The absolute path to the file to write to
+   */
+  file_path: string;
+
+  /**
+   * The content to write to the file
+   */
+  content: string;
+
+  /**
+   * Whether the proposed content was modified by the user.
+   */
+  modified_by_user?: boolean;
+
+  /**
+   * Initially proposed content.
+   */
+  ai_proposed_content?: string;
+}
+
+interface GetCorrectedFileContentResult {
+  originalContent: string;
+  correctedContent: string;
+  fileExists: boolean;
+  error?: { message: string; code?: string };
+}
+
+export async function getCorrectedFileContent(
+  config: Config,
+  filePath: string,
+  proposedContent: string,
+  abortSignal: AbortSignal,
+): Promise<GetCorrectedFileContentResult> {
+  let originalContent = '';
+  let fileExists = false;
+  let correctedContent = proposedContent;
+
+  try {
+    originalContent = await config
+      .getFileSystemService()
+      .readTextFile(filePath);
+    fileExists = true; // File exists and was read
+  } catch (err) {
+    if (isNodeError(err) && err.code === 'ENOENT') {
+      fileExists = false;
+      originalContent = '';
+    } else {
+      // File exists but could not be read (permissions, etc.)
+      fileExists = true; // Mark as existing but problematic
+      originalContent = ''; // Can't use its content
+      const error = {
+        message: getErrorMessage(err),
+        code: isNodeError(err) ? err.code : undefined,
+      };
+      // Return early as we can't proceed with content correction meaningfully
+      return { originalContent, correctedContent, fileExists, error };
+    }
+  }
+
+  // If readError is set, we have returned.
+  // So, file was either read successfully (fileExists=true, originalContent set)
+  // or it was ENOENT (fileExists=false, originalContent='').
+
+  if (fileExists) {
+    // This implies originalContent is available
+    const { params: correctedParams } = await ensureCorrectEdit(
+      filePath,
+      originalContent,
+      {
+        old_string: originalContent, // Treat entire current content as old_string
+        new_string: proposedContent,
+        file_path: filePath,
+      },
+      config.getGeminiClient(),
+      abortSignal,
+    );
+    correctedContent = correctedParams.new_string;
+  } else {
+    // This implies new file (ENOENT)
+    correctedContent = await ensureCorrectFileContent(
+      proposedContent,
+      config.getGeminiClient(),
+      abortSignal,
+    );
+  }
+  return { originalContent, correctedContent, fileExists };
+}
+
+class WriteFileToolInvocation extends BaseToolInvocation<
+  WriteFileToolParams,
+  ToolResult
+> {
+  constructor(
+    private readonly config: Config,
+    params: WriteFileToolParams,
+  ) {
+    super(params);
+  }
+
+  override toolLocations(): ToolLocation[] {
+    return [{ path: this.params.file_path }];
+  }
+
+  override getDescription(): string {
+    const relativePath = makeRelative(
+      this.params.file_path,
+      this.config.getTargetDir(),
+    );
+    return `Writing to ${shortenPath(relativePath)}`;
+  }
+
+  override async shouldConfirmExecute(
+    abortSignal: AbortSignal,
+  ): Promise<ToolCallConfirmationDetails | false> {
+    if (this.config.getApprovalMode() === ApprovalMode.AUTO_EDIT) {
+      return false;
+    }
+
+    const correctedContentResult = await getCorrectedFileContent(
+      this.config,
+      this.params.file_path,
+      this.params.content,
+      abortSignal,
+    );
+
+    if (correctedContentResult.error) {
+      // If file exists but couldn't be read, we can't show a diff for confirmation.
+      return false;
+    }
+
+    const { originalContent, correctedContent } = correctedContentResult;
+    const relativePath = makeRelative(
+      this.params.file_path,
+      this.config.getTargetDir(),
+    );
+    const fileName = path.basename(this.params.file_path);
+
+    const fileDiff = Diff.createPatch(
+      fileName,
+      originalContent, // Original content (empty if new file or unreadable)
+      correctedContent, // Content after potential correction
+      'Current',
+      'Proposed',
+      DEFAULT_DIFF_OPTIONS,
+    );
+
+    const ideClient = this.config.getIdeClient();
+    const ideConfirmation =
+      this.config.getIdeMode() &&
+      ideClient.getConnectionStatus().status === IDEConnectionStatus.Connected
+        ? ideClient.openDiff(this.params.file_path, correctedContent)
+        : undefined;
+
+    const confirmationDetails: ToolEditConfirmationDetails = {
+      type: 'edit',
+      title: `Confirm Write: ${shortenPath(relativePath)}`,
+      fileName,
+      filePath: this.params.file_path,
+      fileDiff,
+      originalContent,
+      newContent: correctedContent,
+      onConfirm: async (outcome: ToolConfirmationOutcome) => {
+        if (outcome === ToolConfirmationOutcome.ProceedAlways) {
+          this.config.setApprovalMode(ApprovalMode.AUTO_EDIT);
+        }
+
+        if (ideConfirmation) {
+          const result = await ideConfirmation;
+          if (result.status === 'accepted' && result.content) {
+            this.params.content = result.content;
+          }
+        }
+      },
+      ideConfirmation,
+    };
+    return confirmationDetails;
+  }
+
+  async execute(abortSignal: AbortSignal): Promise<ToolResult> {
+    const { file_path, content, ai_proposed_content, modified_by_user } =
+      this.params;
+    const correctedContentResult = await getCorrectedFileContent(
+      this.config,
+      file_path,
+      content,
+      abortSignal,
+    );
+
+    if (correctedContentResult.error) {
+      const errDetails = correctedContentResult.error;
+      const errorMsg = errDetails.code
+        ? `Error checking existing file '${file_path}': ${errDetails.message} (${errDetails.code})`
+        : `Error checking existing file: ${errDetails.message}`;
+      return {
+        llmContent: errorMsg,
+        returnDisplay: errorMsg,
+        error: {
+          message: errorMsg,
+          type: ToolErrorType.FILE_WRITE_FAILURE,
+        },
+      };
+    }
+
+    const {
+      originalContent,
+      correctedContent: fileContent,
+      fileExists,
+    } = correctedContentResult;
+    // fileExists is true if the file existed (and was readable or unreadable but caught by readError).
+    // fileExists is false if the file did not exist (ENOENT).
+    const isNewFile =
+      !fileExists ||
+      (correctedContentResult.error !== undefined &&
+        !correctedContentResult.fileExists);
+
+    try {
+      const dirName = path.dirname(file_path);
+      if (!fs.existsSync(dirName)) {
+        fs.mkdirSync(dirName, { recursive: true });
+      }
+
+      await this.config
+        .getFileSystemService()
+        .writeTextFile(file_path, fileContent);
+
+      // Generate diff for display result
+      const fileName = path.basename(file_path);
+      // If there was a readError, originalContent in correctedContentResult is '',
+      // but for the diff, we want to show the original content as it was before the write if possible.
+      // However, if it was unreadable, currentContentForDiff will be empty.
+      const currentContentForDiff = correctedContentResult.error
+        ? '' // Or some indicator of unreadable content
+        : originalContent;
+
+      const fileDiff = Diff.createPatch(
+        fileName,
+        currentContentForDiff,
+        fileContent,
+        'Original',
+        'Written',
+        DEFAULT_DIFF_OPTIONS,
+      );
+
+      const originallyProposedContent = ai_proposed_content || content;
+      const diffStat = getDiffStat(
+        fileName,
+        currentContentForDiff,
+        originallyProposedContent,
+        content,
+      );
+
+      const llmSuccessMessageParts = [
+        isNewFile
+          ? `Successfully created and wrote to new file: ${file_path}.`
+          : `Successfully overwrote file: ${file_path}.`,
+      ];
+      if (modified_by_user) {
+        llmSuccessMessageParts.push(
+          `User modified the \`content\` to be: ${content}`,
+        );
+      }
+
+      const displayResult: FileDiff = {
+        fileDiff,
+        fileName,
+        originalContent: correctedContentResult.originalContent,
+        newContent: correctedContentResult.correctedContent,
+        diffStat,
+      };
+
+      const lines = fileContent.split('\n').length;
+      const mimetype = getSpecificMimeType(file_path);
+      const extension = path.extname(file_path); // Get extension
+      if (isNewFile) {
+        recordFileOperationMetric(
+          this.config,
+          FileOperation.CREATE,
+          lines,
+          mimetype,
+          extension,
+          diffStat,
+        );
+      } else {
+        recordFileOperationMetric(
+          this.config,
+          FileOperation.UPDATE,
+          lines,
+          mimetype,
+          extension,
+          diffStat,
+        );
+      }
+
+      return {
+        llmContent: llmSuccessMessageParts.join(' '),
+        returnDisplay: displayResult,
+      };
+    } catch (error) {
+      // Capture detailed error information for debugging
+      let errorMsg: string;
+      let errorType = ToolErrorType.FILE_WRITE_FAILURE;
+
+      if (isNodeError(error)) {
+        // Handle specific Node.js errors with their error codes
+        errorMsg = `Error writing to file '${file_path}': ${error.message} (${error.code})`;
+
+        // Log specific error types for better debugging
+        if (error.code === 'EACCES') {
+          errorMsg = `Permission denied writing to file: ${file_path} (${error.code})`;
+          errorType = ToolErrorType.PERMISSION_DENIED;
+        } else if (error.code === 'ENOSPC') {
+          errorMsg = `No space left on device: ${file_path} (${error.code})`;
+          errorType = ToolErrorType.NO_SPACE_LEFT;
+        } else if (error.code === 'EISDIR') {
+          errorMsg = `Target is a directory, not a file: ${file_path} (${error.code})`;
+          errorType = ToolErrorType.TARGET_IS_DIRECTORY;
+        }
+
+        // Include stack trace in debug mode for better troubleshooting
+        if (this.config.getDebugMode() && error.stack) {
+          console.error('Write file error stack:', error.stack);
+        }
+      } else if (error instanceof Error) {
+        errorMsg = `Error writing to file: ${error.message}`;
+      } else {
+        errorMsg = `Error writing to file: ${String(error)}`;
+      }
+
+      return {
+        llmContent: errorMsg,
+        returnDisplay: errorMsg,
+        error: {
+          message: errorMsg,
+          type: errorType,
+        },
+      };
+    }
+  }
+}
+
+/**
+ * Implementation of the WriteFile tool logic
+ */
+export class WriteFileTool
+  extends BaseDeclarativeTool<WriteFileToolParams, ToolResult>
+  implements ModifiableDeclarativeTool<WriteFileToolParams>
+{
+  static readonly Name: string = 'write_file';
+
+  constructor(private readonly config: Config) {
+    super(
+      WriteFileTool.Name,
+      'WriteFile',
+      `Writes content to a specified file in the local filesystem.
+
+      The user has the ability to modify \`content\`. If modified, this will be stated in the response.`,
+      Kind.Edit,
+      {
+        properties: {
+          file_path: {
+            description:
+              "The absolute path to the file to write to (e.g., '/home/user/project/file.txt'). Relative paths are not supported.",
+            type: 'string',
+          },
+          content: {
+            description: 'The content to write to the file.',
+            type: 'string',
+          },
+        },
+        required: ['file_path', 'content'],
+        type: 'object',
+      },
+    );
+  }
+
+  protected override validateToolParamValues(
+    params: WriteFileToolParams,
+  ): string | null {
+    const filePath = params.file_path;
+
+    if (!filePath) {
+      return `Missing or empty "file_path"`;
+    }
+
+    if (!path.isAbsolute(filePath)) {
+      return `File path must be absolute: ${filePath}`;
+    }
+
+    const workspaceContext = this.config.getWorkspaceContext();
+    if (!workspaceContext.isPathWithinWorkspace(filePath)) {
+      const directories = workspaceContext.getDirectories();
+      return `File path must be within one of the workspace directories: ${directories.join(
+        ', ',
+      )}`;
+    }
+
+    try {
+      if (fs.existsSync(filePath)) {
+        const stats = fs.lstatSync(filePath);
+        if (stats.isDirectory()) {
+          return `Path is a directory, not a file: ${filePath}`;
+        }
+      }
+    } catch (statError: unknown) {
+      return `Error accessing path properties for validation: ${filePath}. Reason: ${
+        statError instanceof Error ? statError.message : String(statError)
+      }`;
+    }
+
+    return null;
+  }
+
+  protected createInvocation(
+    params: WriteFileToolParams,
+  ): ToolInvocation<WriteFileToolParams, ToolResult> {
+    return new WriteFileToolInvocation(this.config, params);
+  }
+
+  getModifyContext(
+    abortSignal: AbortSignal,
+  ): ModifyContext<WriteFileToolParams> {
+    return {
+      getFilePath: (params: WriteFileToolParams) => params.file_path,
+      getCurrentContent: async (params: WriteFileToolParams) => {
+        const correctedContentResult = await getCorrectedFileContent(
+          this.config,
+          params.file_path,
+          params.content,
+          abortSignal,
+        );
+        return correctedContentResult.originalContent;
+      },
+      getProposedContent: async (params: WriteFileToolParams) => {
+        const correctedContentResult = await getCorrectedFileContent(
+          this.config,
+          params.file_path,
+          params.content,
+          abortSignal,
+        );
+        return correctedContentResult.correctedContent;
+      },
+      createUpdatedParams: (
+        _oldContent: string,
+        modifiedProposedContent: string,
+        originalParams: WriteFileToolParams,
+      ) => {
+        const content = originalParams.content;
+        return {
+          ...originalParams,
+          ai_proposed_content: content,
+          content: modifiedProposedContent,
+          modified_by_user: true,
+        };
+      },
+    };
+  }
+}

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

@@ -0,0 +1,41 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+export class LruCache<K, V> {
+  private cache: Map<K, V>;
+  private maxSize: number;
+
+  constructor(maxSize: number) {
+    this.cache = new Map<K, V>();
+    this.maxSize = maxSize;
+  }
+
+  get(key: K): V | undefined {
+    const value = this.cache.get(key);
+    if (value) {
+      // Move to end to mark as recently used
+      this.cache.delete(key);
+      this.cache.set(key, value);
+    }
+    return value;
+  }
+
+  set(key: K, value: V): void {
+    if (this.cache.has(key)) {
+      this.cache.delete(key);
+    } else if (this.cache.size >= this.maxSize) {
+      const firstKey = this.cache.keys().next().value;
+      if (firstKey !== undefined) {
+        this.cache.delete(firstKey);
+      }
+    }
+    this.cache.set(key, value);
+  }
+
+  clear(): void {
+    this.cache.clear();
+  }
+}

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

@@ -0,0 +1,232 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import * as fsPromises from 'fs/promises';
+import * as path from 'path';
+import * as os from 'os';
+import { bfsFileSearch } from './bfsFileSearch.js';
+import { FileDiscoveryService } from '../services/fileDiscoveryService.js';
+
+describe('bfsFileSearch', () => {
+  let testRootDir: string;
+
+  async function createEmptyDir(...pathSegments: string[]) {
+    const fullPath = path.join(testRootDir, ...pathSegments);
+    await fsPromises.mkdir(fullPath, { recursive: true });
+    return fullPath;
+  }
+
+  async function createTestFile(content: string, ...pathSegments: string[]) {
+    const fullPath = path.join(testRootDir, ...pathSegments);
+    await fsPromises.mkdir(path.dirname(fullPath), { recursive: true });
+    await fsPromises.writeFile(fullPath, content);
+    return fullPath;
+  }
+
+  beforeEach(async () => {
+    testRootDir = await fsPromises.mkdtemp(
+      path.join(os.tmpdir(), 'bfs-file-search-test-'),
+    );
+  });
+
+  afterEach(async () => {
+    await fsPromises.rm(testRootDir, { recursive: true, force: true });
+  });
+
+  it('should find a file in the root directory', async () => {
+    const targetFilePath = await createTestFile('content', 'target.txt');
+    const result = await bfsFileSearch(testRootDir, { fileName: 'target.txt' });
+    expect(result).toEqual([targetFilePath]);
+  });
+
+  it('should find a file in a nested directory', async () => {
+    const targetFilePath = await createTestFile(
+      'content',
+      'a',
+      'b',
+      'target.txt',
+    );
+    const result = await bfsFileSearch(testRootDir, { fileName: 'target.txt' });
+    expect(result).toEqual([targetFilePath]);
+  });
+
+  it('should find multiple files with the same name', async () => {
+    const targetFilePath1 = await createTestFile('content1', 'a', 'target.txt');
+    const targetFilePath2 = await createTestFile('content2', 'b', 'target.txt');
+    const result = await bfsFileSearch(testRootDir, { fileName: 'target.txt' });
+    result.sort();
+    expect(result).toEqual([targetFilePath1, targetFilePath2].sort());
+  });
+
+  it('should return an empty array if no file is found', async () => {
+    await createTestFile('content', 'other.txt');
+    const result = await bfsFileSearch(testRootDir, { fileName: 'target.txt' });
+    expect(result).toEqual([]);
+  });
+
+  it('should ignore directories specified in ignoreDirs', async () => {
+    await createTestFile('content', 'ignored', 'target.txt');
+    const targetFilePath = await createTestFile(
+      'content',
+      'not-ignored',
+      'target.txt',
+    );
+    const result = await bfsFileSearch(testRootDir, {
+      fileName: 'target.txt',
+      ignoreDirs: ['ignored'],
+    });
+    expect(result).toEqual([targetFilePath]);
+  });
+
+  it('should respect the maxDirs limit and not find the file', async () => {
+    await createTestFile('content', 'a', 'b', 'c', 'target.txt');
+    const result = await bfsFileSearch(testRootDir, {
+      fileName: 'target.txt',
+      maxDirs: 3,
+    });
+    expect(result).toEqual([]);
+  });
+
+  it('should respect the maxDirs limit and find the file', async () => {
+    const targetFilePath = await createTestFile(
+      'content',
+      'a',
+      'b',
+      'c',
+      'target.txt',
+    );
+    const result = await bfsFileSearch(testRootDir, {
+      fileName: 'target.txt',
+      maxDirs: 4,
+    });
+    expect(result).toEqual([targetFilePath]);
+  });
+
+  describe('with FileDiscoveryService', () => {
+    let projectRoot: string;
+
+    beforeEach(async () => {
+      projectRoot = await createEmptyDir('project');
+    });
+
+    it('should ignore gitignored files', async () => {
+      await createEmptyDir('project', '.git');
+      await createTestFile('node_modules/', 'project', '.gitignore');
+      await createTestFile('content', 'project', 'node_modules', 'target.txt');
+      const targetFilePath = await createTestFile(
+        'content',
+        'project',
+        'not-ignored',
+        'target.txt',
+      );
+
+      const fileService = new FileDiscoveryService(projectRoot);
+      const result = await bfsFileSearch(projectRoot, {
+        fileName: 'target.txt',
+        fileService,
+        fileFilteringOptions: {
+          respectGitIgnore: true,
+          respectGeminiIgnore: true,
+        },
+      });
+
+      expect(result).toEqual([targetFilePath]);
+    });
+
+    it('should ignore geminiignored files', async () => {
+      await createTestFile('node_modules/', 'project', '.geminiignore');
+      await createTestFile('content', 'project', 'node_modules', 'target.txt');
+      const targetFilePath = await createTestFile(
+        'content',
+        'project',
+        'not-ignored',
+        'target.txt',
+      );
+
+      const fileService = new FileDiscoveryService(projectRoot);
+      const result = await bfsFileSearch(projectRoot, {
+        fileName: 'target.txt',
+        fileService,
+        fileFilteringOptions: {
+          respectGitIgnore: false,
+          respectGeminiIgnore: true,
+        },
+      });
+
+      expect(result).toEqual([targetFilePath]);
+    });
+
+    it('should not ignore files if respect flags are false', async () => {
+      await createEmptyDir('project', '.git');
+      await createTestFile('node_modules/', 'project', '.gitignore');
+      const target1 = await createTestFile(
+        'content',
+        'project',
+        'node_modules',
+        'target.txt',
+      );
+      const target2 = await createTestFile(
+        'content',
+        'project',
+        'not-ignored',
+        'target.txt',
+      );
+
+      const fileService = new FileDiscoveryService(projectRoot);
+      const result = await bfsFileSearch(projectRoot, {
+        fileName: 'target.txt',
+        fileService,
+        fileFilteringOptions: {
+          respectGitIgnore: false,
+          respectGeminiIgnore: false,
+        },
+      });
+
+      expect(result.sort()).toEqual([target1, target2].sort());
+    });
+  });
+
+  it('should find all files in a complex directory structure', async () => {
+    // Create a complex directory structure to test correctness at scale
+    // without flaky performance checks.
+    const numDirs = 50;
+    const numFilesPerDir = 2;
+    const numTargetDirs = 10;
+
+    const dirCreationPromises: Array<Promise<unknown>> = [];
+    for (let i = 0; i < numDirs; i++) {
+      dirCreationPromises.push(createEmptyDir(`dir${i}`));
+      dirCreationPromises.push(createEmptyDir(`dir${i}`, 'subdir1'));
+      dirCreationPromises.push(createEmptyDir(`dir${i}`, 'subdir2'));
+      dirCreationPromises.push(createEmptyDir(`dir${i}`, 'subdir1', 'deep'));
+    }
+    await Promise.all(dirCreationPromises);
+
+    const fileCreationPromises: Array<Promise<string>> = [];
+    for (let i = 0; i < numTargetDirs; i++) {
+      // Add target files in some directories
+      fileCreationPromises.push(
+        createTestFile('content', `dir${i}`, 'QWEN.md'),
+      );
+      fileCreationPromises.push(
+        createTestFile('content', `dir${i}`, 'subdir1', 'QWEN.md'),
+      );
+    }
+    const expectedFiles = await Promise.all(fileCreationPromises);
+
+    const result = await bfsFileSearch(testRootDir, {
+      fileName: 'QWEN.md',
+      // Provide a generous maxDirs limit to ensure it doesn't prematurely stop
+      // in this large test case. Total dirs created is 200.
+      maxDirs: 250,
+    });
+
+    // Verify we found the exact files we created
+    expect(result.length).toBe(numTargetDirs * numFilesPerDir);
+    expect(result.sort()).toEqual(expectedFiles.sort());
+  });
+});

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

@@ -0,0 +1,124 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { FileDiscoveryService } from '../services/fileDiscoveryService.js';
+import { FileFilteringOptions } from '../config/config.js';
+// Simple console logger for now.
+// TODO: Integrate with a more robust server-side logger.
+const logger = {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  debug: (...args: any[]) => console.debug('[DEBUG] [BfsFileSearch]', ...args),
+};
+
+interface BfsFileSearchOptions {
+  fileName: string;
+  ignoreDirs?: string[];
+  maxDirs?: number;
+  debug?: boolean;
+  fileService?: FileDiscoveryService;
+  fileFilteringOptions?: FileFilteringOptions;
+}
+
+/**
+ * Performs a breadth-first search for a specific file within a directory structure.
+ *
+ * @param rootDir The directory to start the search from.
+ * @param options Configuration for the search.
+ * @returns A promise that resolves to an array of paths where the file was found.
+ */
+export async function bfsFileSearch(
+  rootDir: string,
+  options: BfsFileSearchOptions,
+): Promise<string[]> {
+  const {
+    fileName,
+    ignoreDirs = [],
+    maxDirs = Infinity,
+    debug = false,
+    fileService,
+  } = options;
+  const foundFiles: string[] = [];
+  const queue: string[] = [rootDir];
+  const visited = new Set<string>();
+  let scannedDirCount = 0;
+  let queueHead = 0; // Pointer-based queue head to avoid expensive splice operations
+
+  // Convert ignoreDirs array to Set for O(1) lookup performance
+  const ignoreDirsSet = new Set(ignoreDirs);
+
+  // Process directories in parallel batches for maximum performance
+  const PARALLEL_BATCH_SIZE = 15; // Parallel processing batch size for optimal performance
+
+  while (queueHead < queue.length && scannedDirCount < maxDirs) {
+    // Fill batch with unvisited directories up to the desired size
+    const batchSize = Math.min(PARALLEL_BATCH_SIZE, maxDirs - scannedDirCount);
+    const currentBatch = [];
+    while (currentBatch.length < batchSize && queueHead < queue.length) {
+      const currentDir = queue[queueHead];
+      queueHead++;
+      if (!visited.has(currentDir)) {
+        visited.add(currentDir);
+        currentBatch.push(currentDir);
+      }
+    }
+    scannedDirCount += currentBatch.length;
+
+    if (currentBatch.length === 0) continue;
+
+    if (debug) {
+      logger.debug(
+        `Scanning [${scannedDirCount}/${maxDirs}]: batch of ${currentBatch.length}`,
+      );
+    }
+
+    // Read directories in parallel instead of one by one
+    const readPromises = currentBatch.map(async (currentDir) => {
+      try {
+        const entries = await fs.readdir(currentDir, { withFileTypes: true });
+        return { currentDir, entries };
+      } catch (error) {
+        // Warn user that a directory could not be read, as this affects search results.
+        const message = (error as Error)?.message ?? 'Unknown error';
+        console.warn(
+          `[WARN] Skipping unreadable directory: ${currentDir} (${message})`,
+        );
+        if (debug) {
+          logger.debug(`Full error for ${currentDir}:`, error);
+        }
+        return { currentDir, entries: [] };
+      }
+    });
+
+    const results = await Promise.all(readPromises);
+
+    for (const { currentDir, entries } of results) {
+      for (const entry of entries) {
+        const fullPath = path.join(currentDir, entry.name);
+        if (
+          fileService?.shouldIgnoreFile(fullPath, {
+            respectGitIgnore: options.fileFilteringOptions?.respectGitIgnore,
+            respectGeminiIgnore:
+              options.fileFilteringOptions?.respectGeminiIgnore,
+          })
+        ) {
+          continue;
+        }
+
+        if (entry.isDirectory()) {
+          if (!ignoreDirsSet.has(entry.name)) {
+            queue.push(fullPath);
+          }
+        } else if (entry.isFile() && entry.name === fileName) {
+          foundFiles.push(fullPath);
+        }
+      }
+    }
+  }
+
+  return foundFiles;
+}

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

@@ -0,0 +1,56 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Determines if we should attempt to launch a browser for authentication
+ * based on the user's environment.
+ *
+ * This is an adaptation of the logic from the Google Cloud SDK.
+ * @returns True if the tool should attempt to launch a browser.
+ */
+export function shouldAttemptBrowserLaunch(): boolean {
+  // A list of browser names that indicate we should not attempt to open a
+  // web browser for the user.
+  const browserBlocklist = ['www-browser'];
+  const browserEnv = process.env['BROWSER'];
+  if (browserEnv && browserBlocklist.includes(browserEnv)) {
+    return false;
+  }
+  // Common environment variables used in CI/CD or other non-interactive shells.
+  if (
+    process.env['CI'] ||
+    process.env['DEBIAN_FRONTEND'] === 'noninteractive'
+  ) {
+    return false;
+  }
+
+  // The presence of SSH_CONNECTION indicates a remote session.
+  // We should not attempt to launch a browser unless a display is explicitly available
+  // (checked below for Linux).
+  const isSSH = !!process.env['SSH_CONNECTION'];
+
+  // On Linux, the presence of a display server is a strong indicator of a GUI.
+  if (process.platform === 'linux') {
+    // These are environment variables that can indicate a running compositor on
+    // Linux.
+    const displayVariables = ['DISPLAY', 'WAYLAND_DISPLAY', 'MIR_SOCKET'];
+    const hasDisplay = displayVariables.some((v) => !!process.env[v]);
+    if (!hasDisplay) {
+      return false;
+    }
+  }
+
+  // If in an SSH session on a non-Linux OS (e.g., macOS), don't launch browser.
+  // The Linux case is handled above (it's allowed if DISPLAY is set).
+  if (isSSH && process.platform !== 'linux') {
+    return false;
+  }
+
+  // For non-Linux OSes, we generally assume a GUI is available
+  // unless other signals (like SSH) suggest otherwise.
+  // The `open` command's error handling will catch final edge cases.
+  return true;
+}

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

@@ -0,0 +1,767 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import {
+  vi,
+  describe,
+  it,
+  expect,
+  beforeEach,
+  Mock,
+  type Mocked,
+} from 'vitest';
+import * as fs from 'fs';
+import { EditTool } from '../tools/edit.js';
+
+// MOCKS
+let callCount = 0;
+const mockResponses: any[] = [];
+
+let mockGenerateJson: any;
+let mockStartChat: any;
+let mockSendMessageStream: any;
+
+vi.mock('fs', () => ({
+  statSync: vi.fn(),
+}));
+
+vi.mock('../core/client.js', () => ({
+  GeminiClient: vi.fn().mockImplementation(function (
+    this: any,
+    _config: Config,
+  ) {
+    this.generateJson = (...params: any[]) => mockGenerateJson(...params); // Corrected: use mockGenerateJson
+    this.startChat = (...params: any[]) => mockStartChat(...params); // Corrected: use mockStartChat
+    this.sendMessageStream = (...params: any[]) =>
+      mockSendMessageStream(...params); // Corrected: use mockSendMessageStream
+    return this;
+  }),
+}));
+// END MOCKS
+
+import {
+  countOccurrences,
+  ensureCorrectEdit,
+  ensureCorrectFileContent,
+  unescapeStringForGeminiBug,
+  resetEditCorrectorCaches_TEST_ONLY,
+} from './editCorrector.js';
+import { GeminiClient } from '../core/client.js';
+import type { Config } from '../config/config.js';
+import { ToolRegistry } from '../tools/tool-registry.js';
+
+vi.mock('../tools/tool-registry.js');
+
+describe('editCorrector', () => {
+  describe('countOccurrences', () => {
+    it('should return 0 for empty string', () => {
+      expect(countOccurrences('', 'a')).toBe(0);
+    });
+    it('should return 0 for empty substring', () => {
+      expect(countOccurrences('abc', '')).toBe(0);
+    });
+    it('should return 0 if substring is not found', () => {
+      expect(countOccurrences('abc', 'd')).toBe(0);
+    });
+    it('should return 1 if substring is found once', () => {
+      expect(countOccurrences('abc', 'b')).toBe(1);
+    });
+    it('should return correct count for multiple occurrences', () => {
+      expect(countOccurrences('ababa', 'a')).toBe(3);
+      expect(countOccurrences('ababab', 'ab')).toBe(3);
+    });
+    it('should count non-overlapping occurrences', () => {
+      expect(countOccurrences('aaaaa', 'aa')).toBe(2);
+      expect(countOccurrences('ababab', 'aba')).toBe(1);
+    });
+    it('should correctly count occurrences when substring is longer', () => {
+      expect(countOccurrences('abc', 'abcdef')).toBe(0);
+    });
+    it('should be case-sensitive', () => {
+      expect(countOccurrences('abcABC', 'a')).toBe(1);
+      expect(countOccurrences('abcABC', 'A')).toBe(1);
+    });
+  });
+
+  describe('unescapeStringForGeminiBug', () => {
+    it('should unescape common sequences', () => {
+      expect(unescapeStringForGeminiBug('\\n')).toBe('\n');
+      expect(unescapeStringForGeminiBug('\\t')).toBe('\t');
+      expect(unescapeStringForGeminiBug("\\'")).toBe("'");
+      expect(unescapeStringForGeminiBug('\\"')).toBe('"');
+      expect(unescapeStringForGeminiBug('\\`')).toBe('`');
+    });
+    it('should handle multiple escaped sequences', () => {
+      expect(unescapeStringForGeminiBug('Hello\\nWorld\\tTest')).toBe(
+        'Hello\nWorld\tTest',
+      );
+    });
+    it('should not alter already correct sequences', () => {
+      expect(unescapeStringForGeminiBug('\n')).toBe('\n');
+      expect(unescapeStringForGeminiBug('Correct string')).toBe(
+        'Correct string',
+      );
+    });
+    it('should handle mixed correct and incorrect sequences', () => {
+      expect(unescapeStringForGeminiBug('\\nCorrect\t\\`')).toBe(
+        '\nCorrect\t`',
+      );
+    });
+    it('should handle backslash followed by actual newline character', () => {
+      expect(unescapeStringForGeminiBug('\\\n')).toBe('\n');
+      expect(unescapeStringForGeminiBug('First line\\\nSecond line')).toBe(
+        'First line\nSecond line',
+      );
+    });
+    it('should handle multiple backslashes before an escapable character (aggressive unescaping)', () => {
+      expect(unescapeStringForGeminiBug('\\\\n')).toBe('\n');
+      expect(unescapeStringForGeminiBug('\\\\\\t')).toBe('\t');
+      expect(unescapeStringForGeminiBug('\\\\\\\\`')).toBe('`');
+    });
+    it('should return empty string for empty input', () => {
+      expect(unescapeStringForGeminiBug('')).toBe('');
+    });
+    it('should not alter strings with no targeted escape sequences', () => {
+      expect(unescapeStringForGeminiBug('abc def')).toBe('abc def');
+      expect(unescapeStringForGeminiBug('C:\\Folder\\File')).toBe(
+        'C:\\Folder\\File',
+      );
+    });
+    it('should correctly process strings with some targeted escapes', () => {
+      expect(unescapeStringForGeminiBug('C:\\Users\\name')).toBe(
+        'C:\\Users\name',
+      );
+    });
+    it('should handle complex cases with mixed slashes and characters', () => {
+      expect(
+        unescapeStringForGeminiBug('\\\\\\\nLine1\\\nLine2\\tTab\\\\`Tick\\"'),
+      ).toBe('\nLine1\nLine2\tTab`Tick"');
+    });
+    it('should handle escaped backslashes', () => {
+      expect(unescapeStringForGeminiBug('\\\\')).toBe('\\');
+      expect(unescapeStringForGeminiBug('C:\\\\Users')).toBe('C:\\Users');
+      expect(unescapeStringForGeminiBug('path\\\\to\\\\file')).toBe(
+        'path\to\\file',
+      );
+    });
+    it('should handle escaped backslashes mixed with other escapes (aggressive unescaping)', () => {
+      expect(unescapeStringForGeminiBug('line1\\\\\\nline2')).toBe(
+        'line1\nline2',
+      );
+      expect(unescapeStringForGeminiBug('quote\\\\"text\\\\nline')).toBe(
+        'quote"text\nline',
+      );
+    });
+  });
+
+  describe('ensureCorrectEdit', () => {
+    let mockGeminiClientInstance: Mocked<GeminiClient>;
+    let mockToolRegistry: Mocked<ToolRegistry>;
+    let mockConfigInstance: Config;
+    const abortSignal = new AbortController().signal;
+
+    beforeEach(() => {
+      mockToolRegistry = new ToolRegistry({} as Config) as Mocked<ToolRegistry>;
+      const configParams = {
+        apiKey: 'test-api-key',
+        model: 'test-model',
+        sandbox: false as boolean | string,
+        targetDir: '/test',
+        debugMode: false,
+        question: undefined as string | undefined,
+        fullContext: false,
+        coreTools: undefined as string[] | undefined,
+        toolDiscoveryCommand: undefined as string | undefined,
+        toolCallCommand: undefined as string | undefined,
+        mcpServerCommand: undefined as string | undefined,
+        mcpServers: undefined as Record<string, any> | undefined,
+        userAgent: 'test-agent',
+        userMemory: '',
+        geminiMdFileCount: 0,
+        alwaysSkipModificationConfirmation: false,
+      };
+      mockConfigInstance = {
+        ...configParams,
+        getApiKey: vi.fn(() => configParams.apiKey),
+        getModel: vi.fn(() => configParams.model),
+        getSandbox: vi.fn(() => configParams.sandbox),
+        getTargetDir: vi.fn(() => configParams.targetDir),
+        getToolRegistry: vi.fn(() => mockToolRegistry),
+        getDebugMode: vi.fn(() => configParams.debugMode),
+        getQuestion: vi.fn(() => configParams.question),
+        getFullContext: vi.fn(() => configParams.fullContext),
+        getCoreTools: vi.fn(() => configParams.coreTools),
+        getToolDiscoveryCommand: vi.fn(() => configParams.toolDiscoveryCommand),
+        getToolCallCommand: vi.fn(() => configParams.toolCallCommand),
+        getMcpServerCommand: vi.fn(() => configParams.mcpServerCommand),
+        getMcpServers: vi.fn(() => configParams.mcpServers),
+        getUserAgent: vi.fn(() => configParams.userAgent),
+        getUserMemory: vi.fn(() => configParams.userMemory),
+        setUserMemory: vi.fn((mem: string) => {
+          configParams.userMemory = mem;
+        }),
+        getGeminiMdFileCount: vi.fn(() => configParams.geminiMdFileCount),
+        setGeminiMdFileCount: vi.fn((count: number) => {
+          configParams.geminiMdFileCount = count;
+        }),
+        getAlwaysSkipModificationConfirmation: vi.fn(
+          () => configParams.alwaysSkipModificationConfirmation,
+        ),
+        setAlwaysSkipModificationConfirmation: vi.fn((skip: boolean) => {
+          configParams.alwaysSkipModificationConfirmation = skip;
+        }),
+        getQuotaErrorOccurred: vi.fn().mockReturnValue(false),
+        setQuotaErrorOccurred: vi.fn(),
+      } as unknown as Config;
+
+      callCount = 0;
+      mockResponses.length = 0;
+      mockGenerateJson = vi
+        .fn()
+        .mockImplementation((_contents, _schema, signal) => {
+          // Check if the signal is aborted. If so, throw an error or return a specific response.
+          if (signal && signal.aborted) {
+            return Promise.reject(new Error('Aborted')); // Or some other specific error/response
+          }
+          const response = mockResponses[callCount];
+          callCount++;
+          if (response === undefined) return Promise.resolve({});
+          return Promise.resolve(response);
+        });
+      mockStartChat = vi.fn();
+      mockSendMessageStream = vi.fn();
+
+      mockGeminiClientInstance = new GeminiClient(
+        mockConfigInstance,
+      ) as Mocked<GeminiClient>;
+      mockGeminiClientInstance.getHistory = vi.fn().mockResolvedValue([]);
+      resetEditCorrectorCaches_TEST_ONLY();
+    });
+
+    describe('Scenario Group 1: originalParams.old_string matches currentContent directly', () => {
+      it('Test 1.1: old_string (no literal \\), new_string (escaped by Gemini) -> new_string unescaped', async () => {
+        const currentContent = 'This is a test string to find me.';
+        const originalParams = {
+          file_path: '/test/file.txt',
+          old_string: 'find me',
+          new_string: 'replace with \\"this\\"',
+        };
+        mockResponses.push({
+          corrected_new_string_escaping: 'replace with "this"',
+        });
+        const result = await ensureCorrectEdit(
+          '/test/file.txt',
+          currentContent,
+          originalParams,
+          mockGeminiClientInstance,
+          abortSignal,
+        );
+        expect(mockGenerateJson).toHaveBeenCalledTimes(1);
+        expect(result.params.new_string).toBe('replace with "this"');
+        expect(result.params.old_string).toBe('find me');
+        expect(result.occurrences).toBe(1);
+      });
+      it('Test 1.2: old_string (no literal \\), new_string (correctly formatted) -> new_string unchanged', async () => {
+        const currentContent = 'This is a test string to find me.';
+        const originalParams = {
+          file_path: '/test/file.txt',
+          old_string: 'find me',
+          new_string: 'replace with this',
+        };
+        const result = await ensureCorrectEdit(
+          '/test/file.txt',
+          currentContent,
+          originalParams,
+          mockGeminiClientInstance,
+          abortSignal,
+        );
+        expect(mockGenerateJson).toHaveBeenCalledTimes(0);
+        expect(result.params.new_string).toBe('replace with this');
+        expect(result.params.old_string).toBe('find me');
+        expect(result.occurrences).toBe(1);
+      });
+      it('Test 1.3: old_string (with literal \\), new_string (escaped by Gemini) -> new_string unchanged (still escaped)', async () => {
+        const currentContent = 'This is a test string to find\\me.';
+        const originalParams = {
+          file_path: '/test/file.txt',
+          old_string: 'find\\me',
+          new_string: 'replace with \\"this\\"',
+        };
+        mockResponses.push({
+          corrected_new_string_escaping: 'replace with "this"',
+        });
+        const result = await ensureCorrectEdit(
+          '/test/file.txt',
+          currentContent,
+          originalParams,
+          mockGeminiClientInstance,
+          abortSignal,
+        );
+        expect(mockGenerateJson).toHaveBeenCalledTimes(1);
+        expect(result.params.new_string).toBe('replace with "this"');
+        expect(result.params.old_string).toBe('find\\me');
+        expect(result.occurrences).toBe(1);
+      });
+      it('Test 1.4: old_string (with literal \\), new_string (correctly formatted) -> new_string unchanged', async () => {
+        const currentContent = 'This is a test string to find\\me.';
+        const originalParams = {
+          file_path: '/test/file.txt',
+          old_string: 'find\\me',
+          new_string: 'replace with this',
+        };
+        const result = await ensureCorrectEdit(
+          '/test/file.txt',
+          currentContent,
+          originalParams,
+          mockGeminiClientInstance,
+          abortSignal,
+        );
+        expect(mockGenerateJson).toHaveBeenCalledTimes(0);
+        expect(result.params.new_string).toBe('replace with this');
+        expect(result.params.old_string).toBe('find\\me');
+        expect(result.occurrences).toBe(1);
+      });
+    });
+
+    describe('Scenario Group 2: originalParams.old_string does NOT match, but unescapeStringForGeminiBug(originalParams.old_string) DOES match', () => {
+      it('Test 2.1: old_string (over-escaped, no intended literal \\), new_string (escaped by Gemini) -> new_string unescaped', async () => {
+        const currentContent = 'This is a test string to find "me".';
+        const originalParams = {
+          file_path: '/test/file.txt',
+          old_string: 'find \\"me\\"',
+          new_string: 'replace with \\"this\\"',
+        };
+        mockResponses.push({ corrected_new_string: 'replace with "this"' });
+        const result = await ensureCorrectEdit(
+          '/test/file.txt',
+          currentContent,
+          originalParams,
+          mockGeminiClientInstance,
+          abortSignal,
+        );
+        expect(mockGenerateJson).toHaveBeenCalledTimes(1);
+        expect(result.params.new_string).toBe('replace with "this"');
+        expect(result.params.old_string).toBe('find "me"');
+        expect(result.occurrences).toBe(1);
+      });
+      it('Test 2.2: old_string (over-escaped, no intended literal \\), new_string (correctly formatted) -> new_string unescaped (harmlessly)', async () => {
+        const currentContent = 'This is a test string to find "me".';
+        const originalParams = {
+          file_path: '/test/file.txt',
+          old_string: 'find \\"me\\"',
+          new_string: 'replace with this',
+        };
+        const result = await ensureCorrectEdit(
+          '/test/file.txt',
+          currentContent,
+          originalParams,
+          mockGeminiClientInstance,
+          abortSignal,
+        );
+        expect(mockGenerateJson).toHaveBeenCalledTimes(0);
+        expect(result.params.new_string).toBe('replace with this');
+        expect(result.params.old_string).toBe('find "me"');
+        expect(result.occurrences).toBe(1);
+      });
+      it('Test 2.3: old_string (over-escaped, with intended literal \\), new_string (simple) -> new_string corrected', async () => {
+        const currentContent = 'This is a test string to find \\me.';
+        const originalParams = {
+          file_path: '/test/file.txt',
+          old_string: 'find \\\\me',
+          new_string: 'replace with foobar',
+        };
+        const result = await ensureCorrectEdit(
+          '/test/file.txt',
+          currentContent,
+          originalParams,
+          mockGeminiClientInstance,
+          abortSignal,
+        );
+        expect(mockGenerateJson).toHaveBeenCalledTimes(0);
+        expect(result.params.new_string).toBe('replace with foobar');
+        expect(result.params.old_string).toBe('find \\me');
+        expect(result.occurrences).toBe(1);
+      });
+    });
+
+    describe('Scenario Group 3: LLM Correction Path', () => {
+      it('Test 3.1: old_string (no literal \\), new_string (escaped by Gemini), LLM re-escapes new_string -> final new_string is double unescaped', async () => {
+        const currentContent = 'This is a test string to corrected find me.';
+        const originalParams = {
+          file_path: '/test/file.txt',
+          old_string: 'find me',
+          new_string: 'replace with \\\\"this\\\\"',
+        };
+        const llmNewString = 'LLM says replace with "that"';
+        mockResponses.push({ corrected_new_string_escaping: llmNewString });
+        const result = await ensureCorrectEdit(
+          '/test/file.txt',
+          currentContent,
+          originalParams,
+          mockGeminiClientInstance,
+          abortSignal,
+        );
+        expect(mockGenerateJson).toHaveBeenCalledTimes(1);
+        expect(result.params.new_string).toBe(llmNewString);
+        expect(result.params.old_string).toBe('find me');
+        expect(result.occurrences).toBe(1);
+      });
+      it('Test 3.2: old_string (with literal \\), new_string (escaped by Gemini), LLM re-escapes new_string -> final new_string is unescaped once', async () => {
+        const currentContent = 'This is a test string to corrected find me.';
+        const originalParams = {
+          file_path: '/test/file.txt',
+          old_string: 'find\\me',
+          new_string: 'replace with \\\\"this\\\\"',
+        };
+        const llmCorrectedOldString = 'corrected find me';
+        const llmNewString = 'LLM says replace with "that"';
+        mockResponses.push({ corrected_target_snippet: llmCorrectedOldString });
+        mockResponses.push({ corrected_new_string: llmNewString });
+        const result = await ensureCorrectEdit(
+          '/test/file.txt',
+          currentContent,
+          originalParams,
+          mockGeminiClientInstance,
+          abortSignal,
+        );
+        expect(mockGenerateJson).toHaveBeenCalledTimes(2);
+        expect(result.params.new_string).toBe(llmNewString);
+        expect(result.params.old_string).toBe(llmCorrectedOldString);
+        expect(result.occurrences).toBe(1);
+      });
+      it('Test 3.3: old_string needs LLM, new_string is fine -> old_string corrected, new_string original', async () => {
+        const currentContent = 'This is a test string to be corrected.';
+        const originalParams = {
+          file_path: '/test/file.txt',
+          old_string: 'fiiind me',
+          new_string: 'replace with "this"',
+        };
+        const llmCorrectedOldString = 'to be corrected';
+        mockResponses.push({ corrected_target_snippet: llmCorrectedOldString });
+        const result = await ensureCorrectEdit(
+          '/test/file.txt',
+          currentContent,
+          originalParams,
+          mockGeminiClientInstance,
+          abortSignal,
+        );
+        expect(mockGenerateJson).toHaveBeenCalledTimes(1);
+        expect(result.params.new_string).toBe('replace with "this"');
+        expect(result.params.old_string).toBe(llmCorrectedOldString);
+        expect(result.occurrences).toBe(1);
+      });
+      it('Test 3.4: LLM correction path, correctNewString returns the originalNewString it was passed (which was unescaped) -> final new_string is unescaped', async () => {
+        const currentContent = 'This is a test string to corrected find me.';
+        const originalParams = {
+          file_path: '/test/file.txt',
+          old_string: 'find me',
+          new_string: 'replace with \\\\"this\\\\"',
+        };
+        const newStringForLLMAndReturnedByLLM = 'replace with "this"';
+        mockResponses.push({
+          corrected_new_string_escaping: newStringForLLMAndReturnedByLLM,
+        });
+        const result = await ensureCorrectEdit(
+          '/test/file.txt',
+          currentContent,
+          originalParams,
+          mockGeminiClientInstance,
+          abortSignal,
+        );
+        expect(mockGenerateJson).toHaveBeenCalledTimes(1);
+        expect(result.params.new_string).toBe(newStringForLLMAndReturnedByLLM);
+        expect(result.occurrences).toBe(1);
+      });
+    });
+
+    describe('Scenario Group 4: No Match Found / Multiple Matches', () => {
+      it('Test 4.1: No version of old_string (original, unescaped, LLM-corrected) matches -> returns original params, 0 occurrences', async () => {
+        const currentContent = 'This content has nothing to find.';
+        const originalParams = {
+          file_path: '/test/file.txt',
+          old_string: 'nonexistent string',
+          new_string: 'some new string',
+        };
+        mockResponses.push({ corrected_target_snippet: 'still nonexistent' });
+        const result = await ensureCorrectEdit(
+          '/test/file.txt',
+          currentContent,
+          originalParams,
+          mockGeminiClientInstance,
+          abortSignal,
+        );
+        expect(mockGenerateJson).toHaveBeenCalledTimes(1);
+        expect(result.params).toEqual(originalParams);
+        expect(result.occurrences).toBe(0);
+      });
+      it('Test 4.2: unescapedOldStringAttempt results in >1 occurrences -> returns original params, count occurrences', async () => {
+        const currentContent =
+          'This content has find "me" and also find "me" again.';
+        const originalParams = {
+          file_path: '/test/file.txt',
+          old_string: 'find "me"',
+          new_string: 'some new string',
+        };
+        const result = await ensureCorrectEdit(
+          '/test/file.txt',
+          currentContent,
+          originalParams,
+          mockGeminiClientInstance,
+          abortSignal,
+        );
+        expect(mockGenerateJson).toHaveBeenCalledTimes(0);
+        expect(result.params).toEqual(originalParams);
+        expect(result.occurrences).toBe(2);
+      });
+    });
+
+    describe('Scenario Group 5: Specific unescapeStringForGeminiBug checks (integrated into ensureCorrectEdit)', () => {
+      it('Test 5.1: old_string needs LLM to become currentContent, new_string also needs correction', async () => {
+        const currentContent = 'const x = "a\nbc\\"def\\"';
+        const originalParams = {
+          file_path: '/test/file.txt',
+          old_string: 'const x = \\"a\\nbc\\\\"def\\\\"',
+          new_string: 'const y = \\"new\\nval\\\\"content\\\\"',
+        };
+        const expectedFinalNewString = 'const y = "new\nval\\"content\\"';
+        mockResponses.push({ corrected_target_snippet: currentContent });
+        mockResponses.push({ corrected_new_string: expectedFinalNewString });
+        const result = await ensureCorrectEdit(
+          '/test/file.txt',
+          currentContent,
+          originalParams,
+          mockGeminiClientInstance,
+          abortSignal,
+        );
+        expect(mockGenerateJson).toHaveBeenCalledTimes(2);
+        expect(result.params.old_string).toBe(currentContent);
+        expect(result.params.new_string).toBe(expectedFinalNewString);
+        expect(result.occurrences).toBe(1);
+      });
+    });
+
+    describe('Scenario Group 6: Concurrent Edits', () => {
+      it('Test 6.1: should return early if file was modified by another process', async () => {
+        const filePath = '/test/file.txt';
+        const currentContent =
+          'This content has been modified by someone else.';
+        const originalParams = {
+          file_path: filePath,
+          old_string: 'nonexistent string',
+          new_string: 'some new string',
+        };
+
+        const now = Date.now();
+        const lastEditTime = now - 5000; // 5 seconds ago
+
+        // Mock the file's modification time to be recent
+        vi.spyOn(fs, 'statSync').mockReturnValue({
+          mtimeMs: now,
+        } as fs.Stats);
+
+        // Mock the last edit timestamp from our history to be in the past
+        const history = [
+          {
+            role: 'model',
+            parts: [
+              {
+                functionResponse: {
+                  name: EditTool.Name,
+                  id: `${EditTool.Name}-${lastEditTime}-123`,
+                  response: {
+                    output: {
+                      llmContent: `Successfully modified file: ${filePath}`,
+                    },
+                  },
+                },
+              },
+            ],
+          },
+        ];
+        (mockGeminiClientInstance.getHistory as Mock).mockResolvedValue(
+          history,
+        );
+
+        const result = await ensureCorrectEdit(
+          filePath,
+          currentContent,
+          originalParams,
+          mockGeminiClientInstance,
+          abortSignal,
+        );
+
+        expect(result.occurrences).toBe(0);
+        expect(result.params).toEqual(originalParams);
+      });
+    });
+  });
+
+  describe('ensureCorrectFileContent', () => {
+    let mockGeminiClientInstance: Mocked<GeminiClient>;
+    let mockToolRegistry: Mocked<ToolRegistry>;
+    let mockConfigInstance: Config;
+    const abortSignal = new AbortController().signal;
+
+    beforeEach(() => {
+      mockToolRegistry = new ToolRegistry({} as Config) as Mocked<ToolRegistry>;
+      const configParams = {
+        apiKey: 'test-api-key',
+        model: 'test-model',
+        sandbox: false as boolean | string,
+        targetDir: '/test',
+        debugMode: false,
+        question: undefined as string | undefined,
+        fullContext: false,
+        coreTools: undefined as string[] | undefined,
+        toolDiscoveryCommand: undefined as string | undefined,
+        toolCallCommand: undefined as string | undefined,
+        mcpServerCommand: undefined as string | undefined,
+        mcpServers: undefined as Record<string, any> | undefined,
+        userAgent: 'test-agent',
+        userMemory: '',
+        geminiMdFileCount: 0,
+        alwaysSkipModificationConfirmation: false,
+      };
+      mockConfigInstance = {
+        ...configParams,
+        getApiKey: vi.fn(() => configParams.apiKey),
+        getModel: vi.fn(() => configParams.model),
+        getSandbox: vi.fn(() => configParams.sandbox),
+        getTargetDir: vi.fn(() => configParams.targetDir),
+        getToolRegistry: vi.fn(() => mockToolRegistry),
+        getDebugMode: vi.fn(() => configParams.debugMode),
+        getQuestion: vi.fn(() => configParams.question),
+        getFullContext: vi.fn(() => configParams.fullContext),
+        getCoreTools: vi.fn(() => configParams.coreTools),
+        getToolDiscoveryCommand: vi.fn(() => configParams.toolDiscoveryCommand),
+        getToolCallCommand: vi.fn(() => configParams.toolCallCommand),
+        getMcpServerCommand: vi.fn(() => configParams.mcpServerCommand),
+        getMcpServers: vi.fn(() => configParams.mcpServers),
+        getUserAgent: vi.fn(() => configParams.userAgent),
+        getUserMemory: vi.fn(() => configParams.userMemory),
+        setUserMemory: vi.fn((mem: string) => {
+          configParams.userMemory = mem;
+        }),
+        getGeminiMdFileCount: vi.fn(() => configParams.geminiMdFileCount),
+        setGeminiMdFileCount: vi.fn((count: number) => {
+          configParams.geminiMdFileCount = count;
+        }),
+        getAlwaysSkipModificationConfirmation: vi.fn(
+          () => configParams.alwaysSkipModificationConfirmation,
+        ),
+        setAlwaysSkipModificationConfirmation: vi.fn((skip: boolean) => {
+          configParams.alwaysSkipModificationConfirmation = skip;
+        }),
+        getQuotaErrorOccurred: vi.fn().mockReturnValue(false),
+        setQuotaErrorOccurred: vi.fn(),
+      } as unknown as Config;
+
+      callCount = 0;
+      mockResponses.length = 0;
+      mockGenerateJson = vi
+        .fn()
+        .mockImplementation((_contents, _schema, signal) => {
+          if (signal && signal.aborted) {
+            return Promise.reject(new Error('Aborted'));
+          }
+          const response = mockResponses[callCount];
+          callCount++;
+          if (response === undefined) return Promise.resolve({});
+          return Promise.resolve(response);
+        });
+      mockStartChat = vi.fn();
+      mockSendMessageStream = vi.fn();
+
+      mockGeminiClientInstance = new GeminiClient(
+        mockConfigInstance,
+      ) as Mocked<GeminiClient>;
+      resetEditCorrectorCaches_TEST_ONLY();
+    });
+
+    it('should return content unchanged if no escaping issues detected', async () => {
+      const content = 'This is normal content without escaping issues';
+      const result = await ensureCorrectFileContent(
+        content,
+        mockGeminiClientInstance,
+        abortSignal,
+      );
+      expect(result).toBe(content);
+      expect(mockGenerateJson).toHaveBeenCalledTimes(0);
+    });
+
+    it('should call correctStringEscaping for potentially escaped content', async () => {
+      const content = 'console.log(\\"Hello World\\");';
+      const correctedContent = 'console.log("Hello World");';
+      mockResponses.push({
+        corrected_string_escaping: correctedContent,
+      });
+
+      const result = await ensureCorrectFileContent(
+        content,
+        mockGeminiClientInstance,
+        abortSignal,
+      );
+
+      expect(result).toBe(correctedContent);
+      expect(mockGenerateJson).toHaveBeenCalledTimes(1);
+    });
+
+    it('should handle correctStringEscaping returning corrected content via correct property name', async () => {
+      // This test specifically verifies the property name fix
+      const content = 'const message = \\"Hello\\nWorld\\";';
+      const correctedContent = 'const message = "Hello\nWorld";';
+
+      // Mock the response with the correct property name
+      mockResponses.push({
+        corrected_string_escaping: correctedContent,
+      });
+
+      const result = await ensureCorrectFileContent(
+        content,
+        mockGeminiClientInstance,
+        abortSignal,
+      );
+
+      expect(result).toBe(correctedContent);
+      expect(mockGenerateJson).toHaveBeenCalledTimes(1);
+    });
+
+    it('should return original content if LLM correction fails', async () => {
+      const content = 'console.log(\\"Hello World\\");';
+      // Mock empty response to simulate LLM failure
+      mockResponses.push({});
+
+      const result = await ensureCorrectFileContent(
+        content,
+        mockGeminiClientInstance,
+        abortSignal,
+      );
+
+      expect(result).toBe(content);
+      expect(mockGenerateJson).toHaveBeenCalledTimes(1);
+    });
+
+    it('should handle various escape sequences that need correction', async () => {
+      const content =
+        'const obj = { name: \\"John\\", age: 30, bio: \\"Developer\\nEngineer\\" };';
+      const correctedContent =
+        'const obj = { name: "John", age: 30, bio: "Developer\nEngineer" };';
+
+      mockResponses.push({
+        corrected_string_escaping: correctedContent,
+      });
+
+      const result = await ensureCorrectFileContent(
+        content,
+        mockGeminiClientInstance,
+        abortSignal,
+      );
+
+      expect(result).toBe(correctedContent);
+    });
+  });
+});

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

@@ -0,0 +1,750 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { Content, GenerateContentConfig } from '@google/genai';
+import { GeminiClient } from '../core/client.js';
+import { EditToolParams, EditTool } from '../tools/edit.js';
+import { WriteFileTool } from '../tools/write-file.js';
+import { ReadFileTool } from '../tools/read-file.js';
+import { ReadManyFilesTool } from '../tools/read-many-files.js';
+import { GrepTool } from '../tools/grep.js';
+import { LruCache } from './LruCache.js';
+import { DEFAULT_GEMINI_FLASH_LITE_MODEL } from '../config/models.js';
+import {
+  isFunctionResponse,
+  isFunctionCall,
+} from '../utils/messageInspectors.js';
+import * as fs from 'fs';
+
+const EditModel = DEFAULT_GEMINI_FLASH_LITE_MODEL;
+const EditConfig: GenerateContentConfig = {
+  thinkingConfig: {
+    thinkingBudget: 0,
+  },
+};
+
+const MAX_CACHE_SIZE = 50;
+
+// Cache for ensureCorrectEdit results
+const editCorrectionCache = new LruCache<string, CorrectedEditResult>(
+  MAX_CACHE_SIZE,
+);
+
+// Cache for ensureCorrectFileContent results
+const fileContentCorrectionCache = new LruCache<string, string>(MAX_CACHE_SIZE);
+
+/**
+ * Defines the structure of the parameters within CorrectedEditResult
+ */
+interface CorrectedEditParams {
+  file_path: string;
+  old_string: string;
+  new_string: string;
+}
+
+/**
+ * Defines the result structure for ensureCorrectEdit.
+ */
+export interface CorrectedEditResult {
+  params: CorrectedEditParams;
+  occurrences: number;
+}
+
+/**
+ * Extracts the timestamp from the .id value, which is in format
+ * <tool.name>-<timestamp>-<uuid>
+ * @param fcnId the ID value of a functionCall or functionResponse object
+ * @returns -1 if the timestamp could not be extracted, else the timestamp (as a number)
+ */
+function getTimestampFromFunctionId(fcnId: string): number {
+  const idParts = fcnId.split('-');
+  if (idParts.length > 2) {
+    const timestamp = parseInt(idParts[1], 10);
+    if (!isNaN(timestamp)) {
+      return timestamp;
+    }
+  }
+  return -1;
+}
+
+/**
+ * Will look through the gemini client history and determine when the most recent
+ * edit to a target file occurred. If no edit happened, it will return -1
+ * @param filePath the path to the file
+ * @param client the geminiClient, so that we can get the history
+ * @returns a DateTime (as a number) of when the last edit occurred, or -1 if no edit was found.
+ */
+async function findLastEditTimestamp(
+  filePath: string,
+  client: GeminiClient,
+): Promise<number> {
+  const history = (await client.getHistory()) ?? [];
+
+  // Tools that may reference the file path in their FunctionResponse `output`.
+  const toolsInResp = new Set([
+    WriteFileTool.Name,
+    EditTool.Name,
+    ReadManyFilesTool.Name,
+    GrepTool.Name,
+  ]);
+  // Tools that may reference the file path in their FunctionCall `args`.
+  const toolsInCall = new Set([...toolsInResp, ReadFileTool.Name]);
+
+  // Iterate backwards to find the most recent relevant action.
+  for (const entry of history.slice().reverse()) {
+    if (!entry.parts) continue;
+
+    for (const part of entry.parts) {
+      let id: string | undefined;
+      let content: unknown;
+
+      // Check for a relevant FunctionCall with the file path in its arguments.
+      if (
+        isFunctionCall(entry) &&
+        part.functionCall?.name &&
+        toolsInCall.has(part.functionCall.name)
+      ) {
+        id = part.functionCall.id;
+        content = part.functionCall.args;
+      }
+      // Check for a relevant FunctionResponse with the file path in its output.
+      else if (
+        isFunctionResponse(entry) &&
+        part.functionResponse?.name &&
+        toolsInResp.has(part.functionResponse.name)
+      ) {
+        const { response } = part.functionResponse;
+        if (response && !('error' in response) && 'output' in response) {
+          id = part.functionResponse.id;
+          content = response['output'];
+        }
+      }
+
+      if (!id || content === undefined) continue;
+
+      // Use the "blunt hammer" approach to find the file path in the content.
+      // Note that the tool response data is inconsistent in their formatting
+      // with successes and errors - so, we just check for the existence
+      // as the best guess to if error/failed occurred with the response.
+      const stringified = JSON.stringify(content);
+      if (
+        !stringified.includes('Error') && // only applicable for functionResponse
+        !stringified.includes('Failed') && // only applicable for functionResponse
+        stringified.includes(filePath)
+      ) {
+        return getTimestampFromFunctionId(id);
+      }
+    }
+  }
+
+  return -1;
+}
+
+/**
+ * Attempts to correct edit parameters if the original old_string is not found.
+ * It tries unescaping, and then LLM-based correction.
+ * Results are cached to avoid redundant processing.
+ *
+ * @param currentContent The current content of the file.
+ * @param originalParams The original EditToolParams
+ * @param client The GeminiClient for LLM calls.
+ * @returns A promise resolving to an object containing the (potentially corrected)
+ *          EditToolParams (as CorrectedEditParams) and the final occurrences count.
+ */
+export async function ensureCorrectEdit(
+  filePath: string,
+  currentContent: string,
+  originalParams: EditToolParams, // This is the EditToolParams from edit.ts, without \'corrected\'
+  client: GeminiClient,
+  abortSignal: AbortSignal,
+): Promise<CorrectedEditResult> {
+  const cacheKey = `${currentContent}---${originalParams.old_string}---${originalParams.new_string}`;
+  const cachedResult = editCorrectionCache.get(cacheKey);
+  if (cachedResult) {
+    return cachedResult;
+  }
+
+  let finalNewString = originalParams.new_string;
+  const newStringPotentiallyEscaped =
+    unescapeStringForGeminiBug(originalParams.new_string) !==
+    originalParams.new_string;
+
+  const expectedReplacements = originalParams.expected_replacements ?? 1;
+
+  let finalOldString = originalParams.old_string;
+  let occurrences = countOccurrences(currentContent, finalOldString);
+
+  if (occurrences === expectedReplacements) {
+    if (newStringPotentiallyEscaped) {
+      finalNewString = await correctNewStringEscaping(
+        client,
+        finalOldString,
+        originalParams.new_string,
+        abortSignal,
+      );
+    }
+  } else if (occurrences > expectedReplacements) {
+    const expectedReplacements = originalParams.expected_replacements ?? 1;
+
+    // If user expects multiple replacements, return as-is
+    if (occurrences === expectedReplacements) {
+      const result: CorrectedEditResult = {
+        params: { ...originalParams },
+        occurrences,
+      };
+      editCorrectionCache.set(cacheKey, result);
+      return result;
+    }
+
+    // If user expects 1 but found multiple, try to correct (existing behavior)
+    if (expectedReplacements === 1) {
+      const result: CorrectedEditResult = {
+        params: { ...originalParams },
+        occurrences,
+      };
+      editCorrectionCache.set(cacheKey, result);
+      return result;
+    }
+
+    // If occurrences don't match expected, return as-is (will fail validation later)
+    const result: CorrectedEditResult = {
+      params: { ...originalParams },
+      occurrences,
+    };
+    editCorrectionCache.set(cacheKey, result);
+    return result;
+  } else {
+    // occurrences is 0 or some other unexpected state initially
+    const unescapedOldStringAttempt = unescapeStringForGeminiBug(
+      originalParams.old_string,
+    );
+    occurrences = countOccurrences(currentContent, unescapedOldStringAttempt);
+
+    if (occurrences === expectedReplacements) {
+      finalOldString = unescapedOldStringAttempt;
+      if (newStringPotentiallyEscaped) {
+        finalNewString = await correctNewString(
+          client,
+          originalParams.old_string, // original old
+          unescapedOldStringAttempt, // corrected old
+          originalParams.new_string, // original new (which is potentially escaped)
+          abortSignal,
+        );
+      }
+    } else if (occurrences === 0) {
+      if (filePath) {
+        // In order to keep from clobbering edits made outside our system,
+        // let's check if there was a more recent edit to the file than what
+        // our system has done
+        const lastEditedByUsTime = await findLastEditTimestamp(
+          filePath,
+          client,
+        );
+
+        // Add a 1-second buffer to account for timing inaccuracies. If the file
+        // was modified more than a second after the last edit tool was run, we
+        // can assume it was modified by something else.
+        if (lastEditedByUsTime > 0) {
+          const stats = fs.statSync(filePath);
+          const diff = stats.mtimeMs - lastEditedByUsTime;
+          if (diff > 2000) {
+            // Hard coded for 2 seconds
+            // This file was edited sooner
+            const result: CorrectedEditResult = {
+              params: { ...originalParams },
+              occurrences: 0, // Explicitly 0 as LLM failed
+            };
+            editCorrectionCache.set(cacheKey, result);
+            return result;
+          }
+        }
+      }
+
+      const llmCorrectedOldString = await correctOldStringMismatch(
+        client,
+        currentContent,
+        unescapedOldStringAttempt,
+        abortSignal,
+      );
+      const llmOldOccurrences = countOccurrences(
+        currentContent,
+        llmCorrectedOldString,
+      );
+
+      if (llmOldOccurrences === expectedReplacements) {
+        finalOldString = llmCorrectedOldString;
+        occurrences = llmOldOccurrences;
+
+        if (newStringPotentiallyEscaped) {
+          const baseNewStringForLLMCorrection = unescapeStringForGeminiBug(
+            originalParams.new_string,
+          );
+          finalNewString = await correctNewString(
+            client,
+            originalParams.old_string, // original old
+            llmCorrectedOldString, // corrected old
+            baseNewStringForLLMCorrection, // base new for correction
+            abortSignal,
+          );
+        }
+      } else {
+        // LLM correction also failed for old_string
+        const result: CorrectedEditResult = {
+          params: { ...originalParams },
+          occurrences: 0, // Explicitly 0 as LLM failed
+        };
+        editCorrectionCache.set(cacheKey, result);
+        return result;
+      }
+    } else {
+      // Unescaping old_string resulted in > 1 occurrence
+      const result: CorrectedEditResult = {
+        params: { ...originalParams },
+        occurrences, // This will be > 1
+      };
+      editCorrectionCache.set(cacheKey, result);
+      return result;
+    }
+  }
+
+  const { targetString, pair } = trimPairIfPossible(
+    finalOldString,
+    finalNewString,
+    currentContent,
+    expectedReplacements,
+  );
+  finalOldString = targetString;
+  finalNewString = pair;
+
+  // Final result construction
+  const result: CorrectedEditResult = {
+    params: {
+      file_path: originalParams.file_path,
+      old_string: finalOldString,
+      new_string: finalNewString,
+    },
+    occurrences: countOccurrences(currentContent, finalOldString), // Recalculate occurrences with the final old_string
+  };
+  editCorrectionCache.set(cacheKey, result);
+  return result;
+}
+
+export async function ensureCorrectFileContent(
+  content: string,
+  client: GeminiClient,
+  abortSignal: AbortSignal,
+): Promise<string> {
+  const cachedResult = fileContentCorrectionCache.get(content);
+  if (cachedResult) {
+    return cachedResult;
+  }
+
+  const contentPotentiallyEscaped =
+    unescapeStringForGeminiBug(content) !== content;
+  if (!contentPotentiallyEscaped) {
+    fileContentCorrectionCache.set(content, content);
+    return content;
+  }
+
+  const correctedContent = await correctStringEscaping(
+    content,
+    client,
+    abortSignal,
+  );
+  fileContentCorrectionCache.set(content, correctedContent);
+  return correctedContent;
+}
+
+// Define the expected JSON schema for the LLM response for old_string correction
+const OLD_STRING_CORRECTION_SCHEMA: Record<string, unknown> = {
+  type: 'object',
+  properties: {
+    corrected_target_snippet: {
+      type: 'string',
+      description:
+        'The corrected version of the target snippet that exactly and uniquely matches a segment within the provided file content.',
+    },
+  },
+  required: ['corrected_target_snippet'],
+};
+
+export async function correctOldStringMismatch(
+  geminiClient: GeminiClient,
+  fileContent: string,
+  problematicSnippet: string,
+  abortSignal: AbortSignal,
+): Promise<string> {
+  const prompt = `
+Context: A process needs to find an exact literal, unique match for a specific text snippet within a file's content. The provided snippet failed to match exactly. This is most likely because it has been overly escaped.
+
+Task: Analyze the provided file content and the problematic target snippet. Identify the segment in the file content that the snippet was *most likely* intended to match. Output the *exact*, literal text of that segment from the file content. Focus *only* on removing extra escape characters and correcting formatting, whitespace, or minor differences to achieve a PERFECT literal match. The output must be the exact literal text as it appears in the file.
+
+Problematic target snippet:
+\`\`\`
+${problematicSnippet}
+\`\`\`
+
+File Content:
+\`\`\`
+${fileContent}
+\`\`\`
+
+For example, if the problematic target snippet was "\\\\\\nconst greeting = \`Hello \\\\\`\${name}\\\\\`\`;" and the file content had content that looked like "\nconst greeting = \`Hello ${'\\`'}\${name}${'\\`'}\`;", then corrected_target_snippet should likely be "\nconst greeting = \`Hello ${'\\`'}\${name}${'\\`'}\`;" to fix the incorrect escaping to match the original file content.
+If the differences are only in whitespace or formatting, apply similar whitespace/formatting changes to the corrected_target_snippet.
+
+Return ONLY the corrected target snippet in the specified JSON format with the key 'corrected_target_snippet'. If no clear, unique match can be found, return an empty string for 'corrected_target_snippet'.
+`.trim();
+
+  const contents: Content[] = [{ role: 'user', parts: [{ text: prompt }] }];
+
+  try {
+    const result = await geminiClient.generateJson(
+      contents,
+      OLD_STRING_CORRECTION_SCHEMA,
+      abortSignal,
+      EditModel,
+      EditConfig,
+    );
+
+    if (
+      result &&
+      typeof result['corrected_target_snippet'] === 'string' &&
+      result['corrected_target_snippet'].length > 0
+    ) {
+      return result['corrected_target_snippet'];
+    } else {
+      return problematicSnippet;
+    }
+  } catch (error) {
+    if (abortSignal.aborted) {
+      throw error;
+    }
+
+    console.error(
+      'Error during LLM call for old string snippet correction:',
+      error,
+    );
+
+    return problematicSnippet;
+  }
+}
+
+// Define the expected JSON schema for the new_string correction LLM response
+const NEW_STRING_CORRECTION_SCHEMA: Record<string, unknown> = {
+  type: 'object',
+  properties: {
+    corrected_new_string: {
+      type: 'string',
+      description:
+        'The original_new_string adjusted to be a suitable replacement for the corrected_old_string, while maintaining the original intent of the change.',
+    },
+  },
+  required: ['corrected_new_string'],
+};
+
+/**
+ * Adjusts the new_string to align with a corrected old_string, maintaining the original intent.
+ */
+export async function correctNewString(
+  geminiClient: GeminiClient,
+  originalOldString: string,
+  correctedOldString: string,
+  originalNewString: string,
+  abortSignal: AbortSignal,
+): Promise<string> {
+  if (originalOldString === correctedOldString) {
+    return originalNewString;
+  }
+
+  const prompt = `
+Context: A text replacement operation was planned. The original text to be replaced (original_old_string) was slightly different from the actual text in the file (corrected_old_string). The original_old_string has now been corrected to match the file content.
+We now need to adjust the replacement text (original_new_string) so that it makes sense as a replacement for the corrected_old_string, while preserving the original intent of the change.
+
+original_old_string (what was initially intended to be found):
+\`\`\`
+${originalOldString}
+\`\`\`
+
+corrected_old_string (what was actually found in the file and will be replaced):
+\`\`\`
+${correctedOldString}
+\`\`\`
+
+original_new_string (what was intended to replace original_old_string):
+\`\`\`
+${originalNewString}
+\`\`\`
+
+Task: Based on the differences between original_old_string and corrected_old_string, and the content of original_new_string, generate a corrected_new_string. This corrected_new_string should be what original_new_string would have been if it was designed to replace corrected_old_string directly, while maintaining the spirit of the original transformation.
+
+For example, if original_old_string was "\\\\\\nconst greeting = \`Hello \\\\\`\${name}\\\\\`\`;" and corrected_old_string is "\nconst greeting = \`Hello ${'\\`'}\${name}${'\\`'}\`;", and original_new_string was "\\\\\\nconst greeting = \`Hello \\\\\`\${name} \${lastName}\\\\\`\`;", then corrected_new_string should likely be "\nconst greeting = \`Hello ${'\\`'}\${name} \${lastName}${'\\`'}\`;" to fix the incorrect escaping.
+If the differences are only in whitespace or formatting, apply similar whitespace/formatting changes to the corrected_new_string.
+
+Return ONLY the corrected string in the specified JSON format with the key 'corrected_new_string'. If no adjustment is deemed necessary or possible, return the original_new_string.
+  `.trim();
+
+  const contents: Content[] = [{ role: 'user', parts: [{ text: prompt }] }];
+
+  try {
+    const result = await geminiClient.generateJson(
+      contents,
+      NEW_STRING_CORRECTION_SCHEMA,
+      abortSignal,
+      EditModel,
+      EditConfig,
+    );
+
+    if (
+      result &&
+      typeof result['corrected_new_string'] === 'string' &&
+      result['corrected_new_string'].length > 0
+    ) {
+      return result['corrected_new_string'];
+    } else {
+      return originalNewString;
+    }
+  } catch (error) {
+    if (abortSignal.aborted) {
+      throw error;
+    }
+
+    console.error('Error during LLM call for new_string correction:', error);
+    return originalNewString;
+  }
+}
+
+const CORRECT_NEW_STRING_ESCAPING_SCHEMA: Record<string, unknown> = {
+  type: 'object',
+  properties: {
+    corrected_new_string_escaping: {
+      type: 'string',
+      description:
+        'The new_string with corrected escaping, ensuring it is a proper replacement for the old_string, especially considering potential over-escaping issues from previous LLM generations.',
+    },
+  },
+  required: ['corrected_new_string_escaping'],
+};
+
+export async function correctNewStringEscaping(
+  geminiClient: GeminiClient,
+  oldString: string,
+  potentiallyProblematicNewString: string,
+  abortSignal: AbortSignal,
+): Promise<string> {
+  const prompt = `
+Context: A text replacement operation is planned. The text to be replaced (old_string) has been correctly identified in the file. However, the replacement text (new_string) might have been improperly escaped by a previous LLM generation (e.g. too many backslashes for newlines like \\n instead of \n, or unnecessarily quotes like \\"Hello\\" instead of "Hello").
+
+old_string (this is the exact text that will be replaced):
+\`\`\`
+${oldString}
+\`\`\`
+
+potentially_problematic_new_string (this is the text that should replace old_string, but MIGHT have bad escaping, or might be entirely correct):
+\`\`\`
+${potentiallyProblematicNewString}
+\`\`\`
+
+Task: Analyze the potentially_problematic_new_string. If it's syntactically invalid due to incorrect escaping (e.g., "\n", "\t", "\\", "\\'", "\\""), correct the invalid syntax. The goal is to ensure the new_string, when inserted into the code, will be a valid and correctly interpreted.
+
+For example, if old_string is "foo" and potentially_problematic_new_string is "bar\\nbaz", the corrected_new_string_escaping should be "bar\nbaz".
+If potentially_problematic_new_string is console.log(\\"Hello World\\"), it should be console.log("Hello World").
+
+Return ONLY the corrected string in the specified JSON format with the key 'corrected_new_string_escaping'. If no escaping correction is needed, return the original potentially_problematic_new_string.
+  `.trim();
+
+  const contents: Content[] = [{ role: 'user', parts: [{ text: prompt }] }];
+
+  try {
+    const result = await geminiClient.generateJson(
+      contents,
+      CORRECT_NEW_STRING_ESCAPING_SCHEMA,
+      abortSignal,
+      EditModel,
+      EditConfig,
+    );
+
+    if (
+      result &&
+      typeof result['corrected_new_string_escaping'] === 'string' &&
+      result['corrected_new_string_escaping'].length > 0
+    ) {
+      return result['corrected_new_string_escaping'];
+    } else {
+      return potentiallyProblematicNewString;
+    }
+  } catch (error) {
+    if (abortSignal.aborted) {
+      throw error;
+    }
+
+    console.error(
+      'Error during LLM call for new_string escaping correction:',
+      error,
+    );
+    return potentiallyProblematicNewString;
+  }
+}
+
+const CORRECT_STRING_ESCAPING_SCHEMA: Record<string, unknown> = {
+  type: 'object',
+  properties: {
+    corrected_string_escaping: {
+      type: 'string',
+      description:
+        'The string with corrected escaping, ensuring it is valid, specially considering potential over-escaping issues from previous LLM generations.',
+    },
+  },
+  required: ['corrected_string_escaping'],
+};
+
+export async function correctStringEscaping(
+  potentiallyProblematicString: string,
+  client: GeminiClient,
+  abortSignal: AbortSignal,
+): Promise<string> {
+  const prompt = `
+Context: An LLM has just generated potentially_problematic_string and the text might have been improperly escaped (e.g. too many backslashes for newlines like \\n instead of \n, or unnecessarily quotes like \\"Hello\\" instead of "Hello").
+
+potentially_problematic_string (this text MIGHT have bad escaping, or might be entirely correct):
+\`\`\`
+${potentiallyProblematicString}
+\`\`\`
+
+Task: Analyze the potentially_problematic_string. If it's syntactically invalid due to incorrect escaping (e.g., "\n", "\t", "\\", "\\'", "\\""), correct the invalid syntax. The goal is to ensure the text will be a valid and correctly interpreted.
+
+For example, if potentially_problematic_string is "bar\\nbaz", the corrected_new_string_escaping should be "bar\nbaz".
+If potentially_problematic_string is console.log(\\"Hello World\\"), it should be console.log("Hello World").
+
+Return ONLY the corrected string in the specified JSON format with the key 'corrected_string_escaping'. If no escaping correction is needed, return the original potentially_problematic_string.
+  `.trim();
+
+  const contents: Content[] = [{ role: 'user', parts: [{ text: prompt }] }];
+
+  try {
+    const result = await client.generateJson(
+      contents,
+      CORRECT_STRING_ESCAPING_SCHEMA,
+      abortSignal,
+      EditModel,
+      EditConfig,
+    );
+
+    if (
+      result &&
+      typeof result['corrected_string_escaping'] === 'string' &&
+      result['corrected_string_escaping'].length > 0
+    ) {
+      return result['corrected_string_escaping'];
+    } else {
+      return potentiallyProblematicString;
+    }
+  } catch (error) {
+    if (abortSignal.aborted) {
+      throw error;
+    }
+
+    console.error(
+      'Error during LLM call for string escaping correction:',
+      error,
+    );
+    return potentiallyProblematicString;
+  }
+}
+
+function trimPairIfPossible(
+  target: string,
+  trimIfTargetTrims: string,
+  currentContent: string,
+  expectedReplacements: number,
+) {
+  const trimmedTargetString = target.trim();
+  if (target.length !== trimmedTargetString.length) {
+    const trimmedTargetOccurrences = countOccurrences(
+      currentContent,
+      trimmedTargetString,
+    );
+
+    if (trimmedTargetOccurrences === expectedReplacements) {
+      const trimmedReactiveString = trimIfTargetTrims.trim();
+      return {
+        targetString: trimmedTargetString,
+        pair: trimmedReactiveString,
+      };
+    }
+  }
+
+  return {
+    targetString: target,
+    pair: trimIfTargetTrims,
+  };
+}
+
+/**
+ * Unescapes a string that might have been overly escaped by an LLM.
+ */
+export function unescapeStringForGeminiBug(inputString: string): string {
+  // Regex explanation:
+  // \\ : Matches exactly one literal backslash character.
+  // (n|t|r|'|"|`|\\|\n) : This is a capturing group. It matches one of the following:
+  //   n, t, r, ', ", ` : These match the literal characters 'n', 't', 'r', single quote, double quote, or backtick.
+  //                       This handles cases like "\\n", "\\`", etc.
+  //   \\ : This matches a literal backslash. This handles cases like "\\\\" (escaped backslash).
+  //   \n : This matches an actual newline character. This handles cases where the input
+  //        string might have something like "\\\n" (a literal backslash followed by a newline).
+  // g : Global flag, to replace all occurrences.
+
+  return inputString.replace(
+    /\\+(n|t|r|'|"|`|\\|\n)/g,
+    (match, capturedChar) => {
+      // 'match' is the entire erroneous sequence, e.g., if the input (in memory) was "\\\\`", match is "\\\\`".
+      // 'capturedChar' is the character that determines the true meaning, e.g., '`'.
+
+      switch (capturedChar) {
+        case 'n':
+          return '\n'; // Correctly escaped: \n (newline character)
+        case 't':
+          return '\t'; // Correctly escaped: \t (tab character)
+        case 'r':
+          return '\r'; // Correctly escaped: \r (carriage return character)
+        case "'":
+          return "'"; // Correctly escaped: ' (apostrophe character)
+        case '"':
+          return '"'; // Correctly escaped: " (quotation mark character)
+        case '`':
+          return '`'; // Correctly escaped: ` (backtick character)
+        case '\\': // This handles when 'capturedChar' is a literal backslash
+          return '\\'; // Replace escaped backslash (e.g., "\\\\") with single backslash
+        case '\n': // This handles when 'capturedChar' is an actual newline
+          return '\n'; // Replace the whole erroneous sequence (e.g., "\\\n" in memory) with a clean newline
+        default:
+          // This fallback should ideally not be reached if the regex captures correctly.
+          // It would return the original matched sequence if an unexpected character was captured.
+          return match;
+      }
+    },
+  );
+}
+
+/**
+ * Counts occurrences of a substring in a string
+ */
+export function countOccurrences(str: string, substr: string): number {
+  if (substr === '') {
+    return 0;
+  }
+  let count = 0;
+  let pos = str.indexOf(substr);
+  while (pos !== -1) {
+    count++;
+    pos = str.indexOf(substr, pos + substr.length); // Start search after the current match
+  }
+  return count;
+}
+
+export function resetEditCorrectorCaches_TEST_ONLY() {
+  editCorrectionCache.clear();
+  fileContentCorrectionCache.clear();
+}