Add files using upload-large-folder tool

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

@@ -0,0 +1,331 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import fs from 'fs';
+import path from 'path';
+import { glob, escape } from 'glob';
+import {
+  BaseDeclarativeTool,
+  BaseToolInvocation,
+  Kind,
+  ToolInvocation,
+  ToolResult,
+} from './tools.js';
+import { shortenPath, makeRelative } from '../utils/paths.js';
+import { Config } from '../config/config.js';
+
+// Subset of 'Path' interface provided by 'glob' that we can implement for testing
+export interface GlobPath {
+  fullpath(): string;
+  mtimeMs?: number;
+}
+
+/**
+ * Sorts file entries based on recency and then alphabetically.
+ * Recent files (modified within recencyThresholdMs) are listed first, newest to oldest.
+ * Older files are listed after recent ones, sorted alphabetically by path.
+ */
+export function sortFileEntries(
+  entries: GlobPath[],
+  nowTimestamp: number,
+  recencyThresholdMs: number,
+): GlobPath[] {
+  const sortedEntries = [...entries];
+  sortedEntries.sort((a, b) => {
+    const mtimeA = a.mtimeMs ?? 0;
+    const mtimeB = b.mtimeMs ?? 0;
+    const aIsRecent = nowTimestamp - mtimeA < recencyThresholdMs;
+    const bIsRecent = nowTimestamp - mtimeB < recencyThresholdMs;
+
+    if (aIsRecent && bIsRecent) {
+      return mtimeB - mtimeA;
+    } else if (aIsRecent) {
+      return -1;
+    } else if (bIsRecent) {
+      return 1;
+    } else {
+      return a.fullpath().localeCompare(b.fullpath());
+    }
+  });
+  return sortedEntries;
+}
+
+/**
+ * Parameters for the GlobTool
+ */
+export interface GlobToolParams {
+  /**
+   * The glob pattern to match files against
+   */
+  pattern: string;
+
+  /**
+   * The directory to search in (optional, defaults to current directory)
+   */
+  path?: string;
+
+  /**
+   * Whether the search should be case-sensitive (optional, defaults to false)
+   */
+  case_sensitive?: boolean;
+
+  /**
+   * Whether to respect .gitignore patterns (optional, defaults to true)
+   */
+  respect_git_ignore?: boolean;
+}
+
+class GlobToolInvocation extends BaseToolInvocation<
+  GlobToolParams,
+  ToolResult
+> {
+  constructor(
+    private config: Config,
+    params: GlobToolParams,
+  ) {
+    super(params);
+  }
+
+  getDescription(): string {
+    let description = `'${this.params.pattern}'`;
+    if (this.params.path) {
+      const searchDir = path.resolve(
+        this.config.getTargetDir(),
+        this.params.path || '.',
+      );
+      const relativePath = makeRelative(searchDir, this.config.getTargetDir());
+      description += ` within ${shortenPath(relativePath)}`;
+    }
+    return description;
+  }
+
+  async execute(signal: AbortSignal): Promise<ToolResult> {
+    try {
+      const workspaceContext = this.config.getWorkspaceContext();
+      const workspaceDirectories = workspaceContext.getDirectories();
+
+      // If a specific path is provided, resolve it and check if it's within workspace
+      let searchDirectories: readonly string[];
+      if (this.params.path) {
+        const searchDirAbsolute = path.resolve(
+          this.config.getTargetDir(),
+          this.params.path,
+        );
+        if (!workspaceContext.isPathWithinWorkspace(searchDirAbsolute)) {
+          return {
+            llmContent: `Error: Path "${this.params.path}" is not within any workspace directory`,
+            returnDisplay: `Path is not within workspace`,
+          };
+        }
+        searchDirectories = [searchDirAbsolute];
+      } else {
+        // Search across all workspace directories
+        searchDirectories = workspaceDirectories;
+      }
+
+      // Get centralized file discovery service
+      const respectGitIgnore =
+        this.params.respect_git_ignore ??
+        this.config.getFileFilteringRespectGitIgnore();
+      const fileDiscovery = this.config.getFileService();
+
+      // Collect entries from all search directories
+      let allEntries: GlobPath[] = [];
+
+      for (const searchDir of searchDirectories) {
+        let pattern = this.params.pattern;
+        const fullPath = path.join(searchDir, pattern);
+        if (fs.existsSync(fullPath)) {
+          pattern = escape(pattern);
+        }
+
+        const entries = (await glob(pattern, {
+          cwd: searchDir,
+          withFileTypes: true,
+          nodir: true,
+          stat: true,
+          nocase: !this.params.case_sensitive,
+          dot: true,
+          ignore: ['**/node_modules/**', '**/.git/**'],
+          follow: false,
+          signal,
+        })) as GlobPath[];
+
+        allEntries = allEntries.concat(entries);
+      }
+
+      const entries = allEntries;
+
+      // Apply git-aware filtering if enabled and in git repository
+      let filteredEntries = entries;
+      let gitIgnoredCount = 0;
+
+      if (respectGitIgnore) {
+        const relativePaths = entries.map((p) =>
+          path.relative(this.config.getTargetDir(), p.fullpath()),
+        );
+        const filteredRelativePaths = fileDiscovery.filterFiles(relativePaths, {
+          respectGitIgnore,
+        });
+        const filteredAbsolutePaths = new Set(
+          filteredRelativePaths.map((p) =>
+            path.resolve(this.config.getTargetDir(), p),
+          ),
+        );
+
+        filteredEntries = entries.filter((entry) =>
+          filteredAbsolutePaths.has(entry.fullpath()),
+        );
+        gitIgnoredCount = entries.length - filteredEntries.length;
+      }
+
+      if (!filteredEntries || filteredEntries.length === 0) {
+        let message = `No files found matching pattern "${this.params.pattern}"`;
+        if (searchDirectories.length === 1) {
+          message += ` within ${searchDirectories[0]}`;
+        } else {
+          message += ` within ${searchDirectories.length} workspace directories`;
+        }
+        if (gitIgnoredCount > 0) {
+          message += ` (${gitIgnoredCount} files were git-ignored)`;
+        }
+        return {
+          llmContent: message,
+          returnDisplay: `No files found`,
+        };
+      }
+
+      // Set filtering such that we first show the most recent files
+      const oneDayInMs = 24 * 60 * 60 * 1000;
+      const nowTimestamp = new Date().getTime();
+
+      // Sort the filtered entries using the new helper function
+      const sortedEntries = sortFileEntries(
+        filteredEntries,
+        nowTimestamp,
+        oneDayInMs,
+      );
+
+      const sortedAbsolutePaths = sortedEntries.map((entry) =>
+        entry.fullpath(),
+      );
+      const fileListDescription = sortedAbsolutePaths.join('\n');
+      const fileCount = sortedAbsolutePaths.length;
+
+      let resultMessage = `Found ${fileCount} file(s) matching "${this.params.pattern}"`;
+      if (searchDirectories.length === 1) {
+        resultMessage += ` within ${searchDirectories[0]}`;
+      } else {
+        resultMessage += ` across ${searchDirectories.length} workspace directories`;
+      }
+      if (gitIgnoredCount > 0) {
+        resultMessage += ` (${gitIgnoredCount} additional files were git-ignored)`;
+      }
+      resultMessage += `, sorted by modification time (newest first):\n${fileListDescription}`;
+
+      return {
+        llmContent: resultMessage,
+        returnDisplay: `Found ${fileCount} matching file(s)`,
+      };
+    } catch (error) {
+      const errorMessage =
+        error instanceof Error ? error.message : String(error);
+      console.error(`GlobLogic execute Error: ${errorMessage}`, error);
+      return {
+        llmContent: `Error during glob search operation: ${errorMessage}`,
+        returnDisplay: `Error: An unexpected error occurred.`,
+      };
+    }
+  }
+}
+
+/**
+ * Implementation of the Glob tool logic
+ */
+export class GlobTool extends BaseDeclarativeTool<GlobToolParams, ToolResult> {
+  static readonly Name = 'glob';
+
+  constructor(private config: Config) {
+    super(
+      GlobTool.Name,
+      'FindFiles',
+      'Efficiently finds files matching specific glob patterns (e.g., `src/**/*.ts`, `**/*.md`), returning absolute paths sorted by modification time (newest first). Ideal for quickly locating files based on their name or path structure, especially in large codebases.',
+      Kind.Search,
+      {
+        properties: {
+          pattern: {
+            description:
+              "The glob pattern to match against (e.g., '**/*.py', 'docs/*.md').",
+            type: 'string',
+          },
+          path: {
+            description:
+              'Optional: The absolute path to the directory to search within. If omitted, searches the root directory.',
+            type: 'string',
+          },
+          case_sensitive: {
+            description:
+              'Optional: Whether the search should be case-sensitive. Defaults to false.',
+            type: 'boolean',
+          },
+          respect_git_ignore: {
+            description:
+              'Optional: Whether to respect .gitignore patterns when finding files. Only available in git repositories. Defaults to true.',
+            type: 'boolean',
+          },
+        },
+        required: ['pattern'],
+        type: 'object',
+      },
+    );
+  }
+
+  /**
+   * Validates the parameters for the tool.
+   */
+  protected override validateToolParamValues(
+    params: GlobToolParams,
+  ): string | null {
+    const searchDirAbsolute = path.resolve(
+      this.config.getTargetDir(),
+      params.path || '.',
+    );
+
+    const workspaceContext = this.config.getWorkspaceContext();
+    if (!workspaceContext.isPathWithinWorkspace(searchDirAbsolute)) {
+      const directories = workspaceContext.getDirectories();
+      return `Search path ("${searchDirAbsolute}") resolves outside the allowed workspace directories: ${directories.join(', ')}`;
+    }
+
+    const targetDir = searchDirAbsolute || this.config.getTargetDir();
+    try {
+      if (!fs.existsSync(targetDir)) {
+        return `Search path does not exist ${targetDir}`;
+      }
+      if (!fs.statSync(targetDir).isDirectory()) {
+        return `Search path is not a directory: ${targetDir}`;
+      }
+    } catch (e: unknown) {
+      return `Error accessing search path: ${e}`;
+    }
+
+    if (
+      !params.pattern ||
+      typeof params.pattern !== 'string' ||
+      params.pattern.trim() === ''
+    ) {
+      return "The 'pattern' parameter cannot be empty.";
+    }
+
+    return null;
+  }
+
+  protected createInvocation(
+    params: GlobToolParams,
+  ): ToolInvocation<GlobToolParams, ToolResult> {
+    return new GlobToolInvocation(this.config, params);
+  }
+}

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

@@ -0,0 +1,522 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { GrepTool, GrepToolParams } from './grep.js';
+import path from 'path';
+import fs from 'fs/promises';
+import os from 'os';
+import { Config } from '../config/config.js';
+import { createMockWorkspaceContext } from '../test-utils/mockWorkspaceContext.js';
+import { FileDiscoveryService } from '../services/fileDiscoveryService.js';
+
+// Mock the child_process module to control grep/git grep behavior
+vi.mock('child_process', () => ({
+  spawn: vi.fn(() => ({
+    on: (event: string, cb: (...args: unknown[]) => void) => {
+      if (event === 'error' || event === 'close') {
+        // Simulate command not found or error for git grep and system grep
+        // to force it to fall back to JS implementation.
+        setTimeout(() => cb(1), 0); // cb(1) for error/close
+      }
+    },
+    stdout: { on: vi.fn() },
+    stderr: { on: vi.fn() },
+  })),
+}));
+
+describe('GrepTool', () => {
+  let tempRootDir: string;
+  let grepTool: GrepTool;
+  const abortSignal = new AbortController().signal;
+
+  const mockFileService = {
+    getGeminiIgnorePatterns: () => [],
+  } as unknown as FileDiscoveryService;
+
+  const mockConfig = {
+    getTargetDir: () => tempRootDir,
+    getWorkspaceContext: () => createMockWorkspaceContext(tempRootDir),
+    getFileService: () => mockFileService,
+  } as unknown as Config;
+
+  beforeEach(async () => {
+    tempRootDir = await fs.mkdtemp(path.join(os.tmpdir(), 'grep-tool-root-'));
+    grepTool = new GrepTool(mockConfig);
+
+    // Create some test files and directories
+    await fs.writeFile(
+      path.join(tempRootDir, 'fileA.txt'),
+      'hello world\nsecond line with world',
+    );
+    await fs.writeFile(
+      path.join(tempRootDir, 'fileB.js'),
+      'const foo = "bar";\nfunction baz() { return "hello"; }',
+    );
+    await fs.mkdir(path.join(tempRootDir, 'sub'));
+    await fs.writeFile(
+      path.join(tempRootDir, 'sub', 'fileC.txt'),
+      'another world in sub dir',
+    );
+    await fs.writeFile(
+      path.join(tempRootDir, 'sub', 'fileD.md'),
+      '# Markdown file\nThis is a test.',
+    );
+  });
+
+  afterEach(async () => {
+    await fs.rm(tempRootDir, { recursive: true, force: true });
+  });
+
+  describe('validateToolParams', () => {
+    it('should return null for valid params (pattern only)', () => {
+      const params: GrepToolParams = { pattern: 'hello' };
+      expect(grepTool.validateToolParams(params)).toBeNull();
+    });
+
+    it('should return null for valid params (pattern and path)', () => {
+      const params: GrepToolParams = { pattern: 'hello', path: '.' };
+      expect(grepTool.validateToolParams(params)).toBeNull();
+    });
+
+    it('should return null for valid params (pattern, path, and include)', () => {
+      const params: GrepToolParams = {
+        pattern: 'hello',
+        path: '.',
+        include: '*.txt',
+      };
+      expect(grepTool.validateToolParams(params)).toBeNull();
+    });
+
+    it('should return error if pattern is missing', () => {
+      const params = { path: '.' } as unknown as GrepToolParams;
+      expect(grepTool.validateToolParams(params)).toBe(
+        `params must have required property 'pattern'`,
+      );
+    });
+
+    it('should return error for invalid regex pattern', () => {
+      const params: GrepToolParams = { pattern: '[[' };
+      expect(grepTool.validateToolParams(params)).toContain(
+        'Invalid regular expression pattern',
+      );
+    });
+
+    it('should return error if path does not exist', () => {
+      const params: GrepToolParams = { pattern: 'hello', path: 'nonexistent' };
+      // Check for the core error message, as the full path might vary
+      expect(grepTool.validateToolParams(params)).toContain(
+        'Failed to access path stats for',
+      );
+      expect(grepTool.validateToolParams(params)).toContain('nonexistent');
+    });
+
+    it('should return error if path is a file, not a directory', async () => {
+      const filePath = path.join(tempRootDir, 'fileA.txt');
+      const params: GrepToolParams = { pattern: 'hello', path: filePath };
+      expect(grepTool.validateToolParams(params)).toContain(
+        `Path is not a directory: ${filePath}`,
+      );
+    });
+  });
+
+  describe('execute', () => {
+    it('should find matches for a simple pattern in all files', async () => {
+      const params: GrepToolParams = { pattern: 'world' };
+      const invocation = grepTool.build(params);
+      const result = await invocation.execute(abortSignal);
+      expect(result.llmContent).toContain(
+        'Found 3 matches for pattern "world" in the workspace directory',
+      );
+      expect(result.llmContent).toContain('File: fileA.txt');
+      expect(result.llmContent).toContain('L1: hello world');
+      expect(result.llmContent).toContain('L2: second line with world');
+      expect(result.llmContent).toContain(
+        `File: ${path.join('sub', 'fileC.txt')}`,
+      );
+      expect(result.llmContent).toContain('L1: another world in sub dir');
+      expect(result.returnDisplay).toBe('Found 3 matches');
+    });
+
+    it('should find matches in a specific path', async () => {
+      const params: GrepToolParams = { pattern: 'world', path: 'sub' };
+      const invocation = grepTool.build(params);
+      const result = await invocation.execute(abortSignal);
+      expect(result.llmContent).toContain(
+        'Found 1 match for pattern "world" in path "sub"',
+      );
+      expect(result.llmContent).toContain('File: fileC.txt'); // Path relative to 'sub'
+      expect(result.llmContent).toContain('L1: another world in sub dir');
+      expect(result.returnDisplay).toBe('Found 1 match');
+    });
+
+    it('should find matches with an include glob', async () => {
+      const params: GrepToolParams = { pattern: 'hello', include: '*.js' };
+      const invocation = grepTool.build(params);
+      const result = await invocation.execute(abortSignal);
+      expect(result.llmContent).toContain(
+        'Found 1 match for pattern "hello" in the workspace directory (filter: "*.js"):',
+      );
+      expect(result.llmContent).toContain('File: fileB.js');
+      expect(result.llmContent).toContain(
+        'L2: function baz() { return "hello"; }',
+      );
+      expect(result.returnDisplay).toBe('Found 1 match');
+    });
+
+    it('should find matches with an include glob and path', async () => {
+      await fs.writeFile(
+        path.join(tempRootDir, 'sub', 'another.js'),
+        'const greeting = "hello";',
+      );
+      const params: GrepToolParams = {
+        pattern: 'hello',
+        path: 'sub',
+        include: '*.js',
+      };
+      const invocation = grepTool.build(params);
+      const result = await invocation.execute(abortSignal);
+      expect(result.llmContent).toContain(
+        'Found 1 match for pattern "hello" in path "sub" (filter: "*.js")',
+      );
+      expect(result.llmContent).toContain('File: another.js');
+      expect(result.llmContent).toContain('L1: const greeting = "hello";');
+      expect(result.returnDisplay).toBe('Found 1 match');
+    });
+
+    it('should return "No matches found" when pattern does not exist', async () => {
+      const params: GrepToolParams = { pattern: 'nonexistentpattern' };
+      const invocation = grepTool.build(params);
+      const result = await invocation.execute(abortSignal);
+      expect(result.llmContent).toContain(
+        'No matches found for pattern "nonexistentpattern" in the workspace directory.',
+      );
+      expect(result.returnDisplay).toBe('No matches found');
+    });
+
+    it('should handle regex special characters correctly', async () => {
+      const params: GrepToolParams = { pattern: 'foo.*bar' }; // Matches 'const foo = "bar";'
+      const invocation = grepTool.build(params);
+      const result = await invocation.execute(abortSignal);
+      expect(result.llmContent).toContain(
+        'Found 1 match for pattern "foo.*bar" in the workspace directory:',
+      );
+      expect(result.llmContent).toContain('File: fileB.js');
+      expect(result.llmContent).toContain('L1: const foo = "bar";');
+    });
+
+    it('should be case-insensitive by default (JS fallback)', async () => {
+      const params: GrepToolParams = { pattern: 'HELLO' };
+      const invocation = grepTool.build(params);
+      const result = await invocation.execute(abortSignal);
+      expect(result.llmContent).toContain(
+        'Found 2 matches for pattern "HELLO" in the workspace directory:',
+      );
+      expect(result.llmContent).toContain('File: fileA.txt');
+      expect(result.llmContent).toContain('L1: hello world');
+      expect(result.llmContent).toContain('File: fileB.js');
+      expect(result.llmContent).toContain(
+        'L2: function baz() { return "hello"; }',
+      );
+    });
+
+    it('should throw an error if params are invalid', async () => {
+      const params = { path: '.' } as unknown as GrepToolParams; // Invalid: pattern missing
+      expect(() => grepTool.build(params)).toThrow(
+        /params must have required property 'pattern'/,
+      );
+    });
+
+    it('should exclude files matching geminiIgnorePatterns', async () => {
+      // Create a file that should be ignored
+      await fs.writeFile(
+        path.join(tempRootDir, 'ignored-file.txt'),
+        'this file should be ignored\nit contains the word world',
+      );
+
+      // Update the mock file service to return ignore patterns
+      mockFileService.getGeminiIgnorePatterns = () => ['ignored-file.txt'];
+
+      // Re-create the grep tool with the updated mock
+      const grepToolWithIgnore = new GrepTool(mockConfig);
+
+      // Search for 'world' which exists in both the regular file and the ignored file
+      const params: GrepToolParams = { pattern: 'world' };
+      const invocation = grepToolWithIgnore.build(params);
+      const result = await invocation.execute(abortSignal);
+
+      // Should only find matches in the non-ignored files (3 matches)
+      expect(result.llmContent).toContain(
+        'Found 3 matches for pattern "world" in the workspace directory',
+      );
+
+      // Should find matches in the regular files
+      expect(result.llmContent).toContain('File: fileA.txt');
+      expect(result.llmContent).toContain('L1: hello world');
+      expect(result.llmContent).toContain('L2: second line with world');
+      expect(result.llmContent).toContain(
+        `File: ${path.join('sub', 'fileC.txt')}`,
+      );
+      expect(result.llmContent).toContain('L1: another world in sub dir');
+
+      // Should NOT find matches in the ignored file
+      expect(result.llmContent).not.toContain('ignored-file.txt');
+
+      expect(result.returnDisplay).toBe('Found 3 matches');
+    });
+  });
+
+  describe('multi-directory workspace', () => {
+    it('should search across all workspace directories when no path is specified', async () => {
+      // Create additional directory with test files
+      const secondDir = await fs.mkdtemp(
+        path.join(os.tmpdir(), 'grep-tool-second-'),
+      );
+      await fs.writeFile(
+        path.join(secondDir, 'other.txt'),
+        'hello from second directory\nworld in second',
+      );
+      await fs.writeFile(
+        path.join(secondDir, 'another.js'),
+        'function world() { return "test"; }',
+      );
+
+      // Create a mock config with multiple directories
+      const multiDirFileService = {
+        getGeminiIgnorePatterns: () => [],
+      };
+
+      const multiDirConfig = {
+        getTargetDir: () => tempRootDir,
+        getWorkspaceContext: () =>
+          createMockWorkspaceContext(tempRootDir, [secondDir]),
+        getFileService: () => multiDirFileService,
+      } as unknown as Config;
+
+      const multiDirGrepTool = new GrepTool(multiDirConfig);
+      const params: GrepToolParams = { pattern: 'world' };
+      const invocation = multiDirGrepTool.build(params);
+      const result = await invocation.execute(abortSignal);
+
+      // Should find matches in both directories
+      expect(result.llmContent).toContain(
+        'Found 5 matches for pattern "world"',
+      );
+
+      // Matches from first directory
+      expect(result.llmContent).toContain('fileA.txt');
+      expect(result.llmContent).toContain('L1: hello world');
+      expect(result.llmContent).toContain('L2: second line with world');
+      expect(result.llmContent).toContain('fileC.txt');
+      expect(result.llmContent).toContain('L1: another world in sub dir');
+
+      // Matches from second directory (with directory name prefix)
+      const secondDirName = path.basename(secondDir);
+      expect(result.llmContent).toContain(
+        `File: ${path.join(secondDirName, 'other.txt')}`,
+      );
+      expect(result.llmContent).toContain('L2: world in second');
+      expect(result.llmContent).toContain(
+        `File: ${path.join(secondDirName, 'another.js')}`,
+      );
+      expect(result.llmContent).toContain('L1: function world()');
+
+      // Clean up
+      await fs.rm(secondDir, { recursive: true, force: true });
+    });
+
+    it('should search only specified path within workspace directories', async () => {
+      // Create additional directory
+      const secondDir = await fs.mkdtemp(
+        path.join(os.tmpdir(), 'grep-tool-second-'),
+      );
+      await fs.mkdir(path.join(secondDir, 'sub'));
+      await fs.writeFile(
+        path.join(secondDir, 'sub', 'test.txt'),
+        'hello from second sub directory',
+      );
+
+      // Create a mock config with multiple directories
+      const multiDirFileService = {
+        getGeminiIgnorePatterns: () => [],
+      };
+
+      const multiDirConfig = {
+        getTargetDir: () => tempRootDir,
+        getWorkspaceContext: () =>
+          createMockWorkspaceContext(tempRootDir, [secondDir]),
+        getFileService: () => multiDirFileService,
+      } as unknown as Config;
+
+      const multiDirGrepTool = new GrepTool(multiDirConfig);
+
+      // Search only in the 'sub' directory of the first workspace
+      const params: GrepToolParams = { pattern: 'world', path: 'sub' };
+      const invocation = multiDirGrepTool.build(params);
+      const result = await invocation.execute(abortSignal);
+
+      // Should only find matches in the specified sub directory
+      expect(result.llmContent).toContain(
+        'Found 1 match for pattern "world" in path "sub"',
+      );
+      expect(result.llmContent).toContain('File: fileC.txt');
+      expect(result.llmContent).toContain('L1: another world in sub dir');
+
+      // Should not contain matches from second directory
+      expect(result.llmContent).not.toContain('test.txt');
+
+      // Clean up
+      await fs.rm(secondDir, { recursive: true, force: true });
+    });
+  });
+
+  describe('getDescription', () => {
+    it('should generate correct description with pattern only', () => {
+      const params: GrepToolParams = { pattern: 'testPattern' };
+      const invocation = grepTool.build(params);
+      expect(invocation.getDescription()).toBe("'testPattern'");
+    });
+
+    it('should generate correct description with pattern and include', () => {
+      const params: GrepToolParams = {
+        pattern: 'testPattern',
+        include: '*.ts',
+      };
+      const invocation = grepTool.build(params);
+      expect(invocation.getDescription()).toBe("'testPattern' in *.ts");
+    });
+
+    it('should generate correct description with pattern and path', async () => {
+      const dirPath = path.join(tempRootDir, 'src', 'app');
+      await fs.mkdir(dirPath, { recursive: true });
+      const params: GrepToolParams = {
+        pattern: 'testPattern',
+        path: path.join('src', 'app'),
+      };
+      const invocation = grepTool.build(params);
+      // The path will be relative to the tempRootDir, so we check for containment.
+      expect(invocation.getDescription()).toContain("'testPattern' within");
+      expect(invocation.getDescription()).toContain(path.join('src', 'app'));
+    });
+
+    it('should indicate searching across all workspace directories when no path specified', () => {
+      // Create a mock config with multiple directories
+      const multiDirConfig = {
+        getTargetDir: () => tempRootDir,
+        getWorkspaceContext: () =>
+          createMockWorkspaceContext(tempRootDir, ['/another/dir']),
+      } as unknown as Config;
+
+      const multiDirGrepTool = new GrepTool(multiDirConfig);
+      const params: GrepToolParams = { pattern: 'testPattern' };
+      const invocation = multiDirGrepTool.build(params);
+      expect(invocation.getDescription()).toBe(
+        "'testPattern' across all workspace directories",
+      );
+    });
+
+    it('should generate correct description with pattern, include, and path', async () => {
+      const dirPath = path.join(tempRootDir, 'src', 'app');
+      await fs.mkdir(dirPath, { recursive: true });
+      const params: GrepToolParams = {
+        pattern: 'testPattern',
+        include: '*.ts',
+        path: path.join('src', 'app'),
+      };
+      const invocation = grepTool.build(params);
+      expect(invocation.getDescription()).toContain(
+        "'testPattern' in *.ts within",
+      );
+      expect(invocation.getDescription()).toContain(path.join('src', 'app'));
+    });
+
+    it('should use ./ for root path in description', () => {
+      const params: GrepToolParams = { pattern: 'testPattern', path: '.' };
+      const invocation = grepTool.build(params);
+      expect(invocation.getDescription()).toBe("'testPattern' within ./");
+    });
+  });
+
+  describe('Result limiting', () => {
+    beforeEach(async () => {
+      // Create many test files with matches to test limiting
+      for (let i = 1; i <= 30; i++) {
+        const fileName = `test${i}.txt`;
+        const content = `This is test file ${i} with the pattern testword in it.`;
+        await fs.writeFile(path.join(tempRootDir, fileName), content);
+      }
+    });
+
+    it('should limit results to default 20 matches', async () => {
+      const params: GrepToolParams = { pattern: 'testword' };
+      const invocation = grepTool.build(params);
+      const result = await invocation.execute(abortSignal);
+
+      expect(result.llmContent).toContain('Found 20 matches');
+      expect(result.llmContent).toContain(
+        'showing first 20 of 30+ total matches',
+      );
+      expect(result.llmContent).toContain('WARNING: Results truncated');
+      expect(result.returnDisplay).toContain(
+        'Found 20 matches (truncated from 30+)',
+      );
+    });
+
+    it('should respect custom maxResults parameter', async () => {
+      const params: GrepToolParams = { pattern: 'testword', maxResults: 5 };
+      const invocation = grepTool.build(params);
+      const result = await invocation.execute(abortSignal);
+
+      expect(result.llmContent).toContain('Found 5 matches');
+      expect(result.llmContent).toContain(
+        'showing first 5 of 30+ total matches',
+      );
+      expect(result.llmContent).toContain('current: 5');
+      expect(result.returnDisplay).toContain(
+        'Found 5 matches (truncated from 30+)',
+      );
+    });
+
+    it('should not show truncation warning when all results fit', async () => {
+      const params: GrepToolParams = { pattern: 'testword', maxResults: 50 };
+      const invocation = grepTool.build(params);
+      const result = await invocation.execute(abortSignal);
+
+      expect(result.llmContent).toContain('Found 30 matches');
+      expect(result.llmContent).not.toContain('WARNING: Results truncated');
+      expect(result.llmContent).not.toContain('showing first');
+      expect(result.returnDisplay).toBe('Found 30 matches');
+    });
+
+    it('should validate maxResults parameter', () => {
+      const invalidParams = [
+        { pattern: 'test', maxResults: 0 },
+        { pattern: 'test', maxResults: 101 },
+        { pattern: 'test', maxResults: -1 },
+        { pattern: 'test', maxResults: 1.5 },
+      ];
+
+      invalidParams.forEach((params) => {
+        const error = grepTool.validateToolParams(params as GrepToolParams);
+        expect(error).toBeTruthy(); // Just check that validation fails
+        expect(error).toMatch(/maxResults|must be/); // Check it's about maxResults validation
+      });
+    });
+
+    it('should accept valid maxResults parameter', () => {
+      const validParams = [
+        { pattern: 'test', maxResults: 1 },
+        { pattern: 'test', maxResults: 50 },
+        { pattern: 'test', maxResults: 100 },
+      ];
+
+      validParams.forEach((params) => {
+        const error = grepTool.validateToolParams(params);
+        expect(error).toBeNull();
+      });
+    });
+  });
+});

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

@@ -0,0 +1,711 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import fs from 'fs';
+import fsPromises from 'fs/promises';
+import path from 'path';
+import { EOL } from 'os';
+import { spawn } from 'child_process';
+import { globStream } from 'glob';
+import {
+  BaseDeclarativeTool,
+  BaseToolInvocation,
+  Kind,
+  ToolInvocation,
+  ToolResult,
+} from './tools.js';
+import { makeRelative, shortenPath } from '../utils/paths.js';
+import { getErrorMessage, isNodeError } from '../utils/errors.js';
+import { isGitRepository } from '../utils/gitUtils.js';
+import { Config } from '../config/config.js';
+
+// --- Interfaces ---
+
+/**
+ * Parameters for the GrepTool
+ */
+export interface GrepToolParams {
+  /**
+   * The regular expression pattern to search for in file contents
+   */
+  pattern: string;
+
+  /**
+   * The directory to search in (optional, defaults to current directory relative to root)
+   */
+  path?: string;
+
+  /**
+   * File pattern to include in the search (e.g. "*.js", "*.{ts,tsx}")
+   */
+  include?: string;
+
+  /**
+   * Maximum number of matches to return (optional, defaults to 20)
+   */
+  maxResults?: number;
+}
+
+/**
+ * Result object for a single grep match
+ */
+interface GrepMatch {
+  filePath: string;
+  lineNumber: number;
+  line: string;
+}
+
+class GrepToolInvocation extends BaseToolInvocation<
+  GrepToolParams,
+  ToolResult
+> {
+  constructor(
+    private readonly config: Config,
+    params: GrepToolParams,
+  ) {
+    super(params);
+  }
+
+  /**
+   * Checks if a path is within the root directory and resolves it.
+   * @param relativePath Path relative to the root directory (or undefined for root).
+   * @returns The absolute path if valid and exists, or null if no path specified (to search all directories).
+   * @throws {Error} If path is outside root, doesn't exist, or isn't a directory.
+   */
+  private resolveAndValidatePath(relativePath?: string): string | null {
+    // If no path specified, return null to indicate searching all workspace directories
+    if (!relativePath) {
+      return null;
+    }
+
+    const targetPath = path.resolve(this.config.getTargetDir(), relativePath);
+
+    // Security Check: Ensure the resolved path is within workspace boundaries
+    const workspaceContext = this.config.getWorkspaceContext();
+    if (!workspaceContext.isPathWithinWorkspace(targetPath)) {
+      const directories = workspaceContext.getDirectories();
+      throw new Error(
+        `Path validation failed: Attempted path "${relativePath}" resolves outside the allowed workspace directories: ${directories.join(', ')}`,
+      );
+    }
+
+    // Check existence and type after resolving
+    try {
+      const stats = fs.statSync(targetPath);
+      if (!stats.isDirectory()) {
+        throw new Error(`Path is not a directory: ${targetPath}`);
+      }
+    } catch (error: unknown) {
+      if (isNodeError(error) && error.code !== 'ENOENT') {
+        throw new Error(`Path does not exist: ${targetPath}`);
+      }
+      throw new Error(
+        `Failed to access path stats for ${targetPath}: ${error}`,
+      );
+    }
+
+    return targetPath;
+  }
+
+  async execute(signal: AbortSignal): Promise<ToolResult> {
+    try {
+      const workspaceContext = this.config.getWorkspaceContext();
+      const searchDirAbs = this.resolveAndValidatePath(this.params.path);
+      const searchDirDisplay = this.params.path || '.';
+
+      // Determine which directories to search
+      let searchDirectories: readonly string[];
+      if (searchDirAbs === null) {
+        // No path specified - search all workspace directories
+        searchDirectories = workspaceContext.getDirectories();
+      } else {
+        // Specific path provided - search only that directory
+        searchDirectories = [searchDirAbs];
+      }
+
+      // Collect matches from all search directories
+      let allMatches: GrepMatch[] = [];
+      const maxResults = this.params.maxResults ?? 20; // Default to 20 results
+      let totalMatchesFound = 0;
+      let searchTruncated = false;
+
+      for (const searchDir of searchDirectories) {
+        const matches = await this.performGrepSearch({
+          pattern: this.params.pattern,
+          path: searchDir,
+          include: this.params.include,
+          signal,
+        });
+
+        totalMatchesFound += matches.length;
+
+        // Add directory prefix if searching multiple directories
+        if (searchDirectories.length > 1) {
+          const dirName = path.basename(searchDir);
+          matches.forEach((match) => {
+            match.filePath = path.join(dirName, match.filePath);
+          });
+        }
+
+        // Apply result limiting
+        const remainingSlots = maxResults - allMatches.length;
+        if (remainingSlots <= 0) {
+          searchTruncated = true;
+          break;
+        }
+
+        if (matches.length > remainingSlots) {
+          allMatches = allMatches.concat(matches.slice(0, remainingSlots));
+          searchTruncated = true;
+          break;
+        } else {
+          allMatches = allMatches.concat(matches);
+        }
+      }
+
+      let searchLocationDescription: string;
+      if (searchDirAbs === null) {
+        const numDirs = workspaceContext.getDirectories().length;
+        searchLocationDescription =
+          numDirs > 1
+            ? `across ${numDirs} workspace directories`
+            : `in the workspace directory`;
+      } else {
+        searchLocationDescription = `in path "${searchDirDisplay}"`;
+      }
+
+      if (allMatches.length === 0) {
+        const noMatchMsg = `No matches found for pattern "${this.params.pattern}" ${searchLocationDescription}${this.params.include ? ` (filter: "${this.params.include}")` : ''}.`;
+        return { llmContent: noMatchMsg, returnDisplay: `No matches found` };
+      }
+
+      // Group matches by file
+      const matchesByFile = allMatches.reduce(
+        (acc, match) => {
+          const fileKey = match.filePath;
+          if (!acc[fileKey]) {
+            acc[fileKey] = [];
+          }
+          acc[fileKey].push(match);
+          acc[fileKey].sort((a, b) => a.lineNumber - b.lineNumber);
+          return acc;
+        },
+        {} as Record<string, GrepMatch[]>,
+      );
+
+      const matchCount = allMatches.length;
+      const matchTerm = matchCount === 1 ? 'match' : 'matches';
+
+      // Build the header with truncation info if needed
+      let headerText = `Found ${matchCount} ${matchTerm} for pattern "${this.params.pattern}" ${searchLocationDescription}${this.params.include ? ` (filter: "${this.params.include}")` : ''}`;
+
+      if (searchTruncated) {
+        headerText += ` (showing first ${matchCount} of ${totalMatchesFound}+ total matches)`;
+      }
+
+      let llmContent = `${headerText}:
+---
+`;
+
+      for (const filePath in matchesByFile) {
+        llmContent += `File: ${filePath}\n`;
+        matchesByFile[filePath].forEach((match) => {
+          const trimmedLine = match.line.trim();
+          llmContent += `L${match.lineNumber}: ${trimmedLine}\n`;
+        });
+        llmContent += '---\n';
+      }
+
+      // Add truncation guidance if results were limited
+      if (searchTruncated) {
+        llmContent += `\nWARNING: Results truncated to prevent context overflow. To see more results:
+- Use a more specific pattern to reduce matches
+- Add file filters with the 'include' parameter (e.g., "*.js", "src/**")
+- Specify a narrower 'path' to search in a subdirectory
+- Increase 'maxResults' parameter if you need more matches (current: ${maxResults})`;
+      }
+
+      let displayText = `Found ${matchCount} ${matchTerm}`;
+      if (searchTruncated) {
+        displayText += ` (truncated from ${totalMatchesFound}+)`;
+      }
+
+      return {
+        llmContent: llmContent.trim(),
+        returnDisplay: displayText,
+      };
+    } catch (error) {
+      console.error(`Error during GrepLogic execution: ${error}`);
+      const errorMessage = getErrorMessage(error);
+      return {
+        llmContent: `Error during grep search operation: ${errorMessage}`,
+        returnDisplay: `Error: ${errorMessage}`,
+      };
+    }
+  }
+
+  /**
+   * Checks if a command is available in the system's PATH.
+   * @param {string} command The command name (e.g., 'git', 'grep').
+   * @returns {Promise<boolean>} True if the command is available, false otherwise.
+   */
+  private isCommandAvailable(command: string): Promise<boolean> {
+    return new Promise((resolve) => {
+      const checkCommand = process.platform === 'win32' ? 'where' : 'command';
+      const checkArgs =
+        process.platform === 'win32' ? [command] : ['-v', command];
+      try {
+        const child = spawn(checkCommand, checkArgs, {
+          stdio: 'ignore',
+          shell: process.platform === 'win32',
+        });
+        child.on('close', (code) => resolve(code === 0));
+        child.on('error', () => resolve(false));
+      } catch {
+        resolve(false);
+      }
+    });
+  }
+
+  /**
+   * Parses the standard output of grep-like commands (git grep, system grep).
+   * Expects format: filePath:lineNumber:lineContent
+   * Handles colons within file paths and line content correctly.
+   * @param {string} output The raw stdout string.
+   * @param {string} basePath The absolute directory the search was run from, for relative paths.
+   * @returns {GrepMatch[]} Array of match objects.
+   */
+  private parseGrepOutput(output: string, basePath: string): GrepMatch[] {
+    const results: GrepMatch[] = [];
+    if (!output) return results;
+
+    const lines = output.split(EOL); // Use OS-specific end-of-line
+
+    for (const line of lines) {
+      if (!line.trim()) continue;
+
+      // Find the index of the first colon.
+      const firstColonIndex = line.indexOf(':');
+      if (firstColonIndex === -1) continue; // Malformed
+
+      // Find the index of the second colon, searching *after* the first one.
+      const secondColonIndex = line.indexOf(':', firstColonIndex + 1);
+      if (secondColonIndex === -1) continue; // Malformed
+
+      // Extract parts based on the found colon indices
+      const filePathRaw = line.substring(0, firstColonIndex);
+      const lineNumberStr = line.substring(
+        firstColonIndex + 1,
+        secondColonIndex,
+      );
+      const lineContent = line.substring(secondColonIndex + 1);
+
+      const lineNumber = parseInt(lineNumberStr, 10);
+
+      if (!isNaN(lineNumber)) {
+        const absoluteFilePath = path.resolve(basePath, filePathRaw);
+        const relativeFilePath = path.relative(basePath, absoluteFilePath);
+
+        results.push({
+          filePath: relativeFilePath || path.basename(absoluteFilePath),
+          lineNumber,
+          line: lineContent,
+        });
+      }
+    }
+    return results;
+  }
+
+  /**
+   * Gets a description of the grep operation
+   * @param params Parameters for the grep operation
+   * @returns A string describing the grep
+   */
+  getDescription(): string {
+    let description = `'${this.params.pattern}'`;
+    if (this.params.include) {
+      description += ` in ${this.params.include}`;
+    }
+    if (this.params.path) {
+      const resolvedPath = path.resolve(
+        this.config.getTargetDir(),
+        this.params.path,
+      );
+      if (
+        resolvedPath === this.config.getTargetDir() ||
+        this.params.path === '.'
+      ) {
+        description += ` within ./`;
+      } else {
+        const relativePath = makeRelative(
+          resolvedPath,
+          this.config.getTargetDir(),
+        );
+        description += ` within ${shortenPath(relativePath)}`;
+      }
+    } else {
+      // When no path is specified, indicate searching all workspace directories
+      const workspaceContext = this.config.getWorkspaceContext();
+      const directories = workspaceContext.getDirectories();
+      if (directories.length > 1) {
+        description += ` across all workspace directories`;
+      }
+    }
+    return description;
+  }
+
+  /**
+   * Performs the actual search using the prioritized strategies.
+   * @param options Search options including pattern, absolute path, and include glob.
+   * @returns A promise resolving to an array of match objects.
+   */
+  private async performGrepSearch(options: {
+    pattern: string;
+    path: string; // Expects absolute path
+    include?: string;
+    signal: AbortSignal;
+  }): Promise<GrepMatch[]> {
+    const { pattern, path: absolutePath, include } = options;
+    let strategyUsed = 'none';
+
+    try {
+      // --- Strategy 1: git grep ---
+      const isGit = isGitRepository(absolutePath);
+      const gitAvailable = isGit && (await this.isCommandAvailable('git'));
+
+      if (gitAvailable) {
+        strategyUsed = 'git grep';
+        const gitArgs = [
+          'grep',
+          '--untracked',
+          '-n',
+          '-E',
+          '--ignore-case',
+          pattern,
+        ];
+        if (include) {
+          gitArgs.push('--', include);
+        }
+
+        try {
+          const output = await new Promise<string>((resolve, reject) => {
+            const child = spawn('git', gitArgs, {
+              cwd: absolutePath,
+              windowsHide: true,
+            });
+            const stdoutChunks: Buffer[] = [];
+            const stderrChunks: Buffer[] = [];
+
+            child.stdout.on('data', (chunk) => stdoutChunks.push(chunk));
+            child.stderr.on('data', (chunk) => stderrChunks.push(chunk));
+            child.on('error', (err) =>
+              reject(new Error(`Failed to start git grep: ${err.message}`)),
+            );
+            child.on('close', (code) => {
+              const stdoutData = Buffer.concat(stdoutChunks).toString('utf8');
+              const stderrData = Buffer.concat(stderrChunks).toString('utf8');
+              if (code === 0) resolve(stdoutData);
+              else if (code === 1)
+                resolve(''); // No matches
+              else
+                reject(
+                  new Error(`git grep exited with code ${code}: ${stderrData}`),
+                );
+            });
+          });
+          return this.parseGrepOutput(output, absolutePath);
+        } catch (gitError: unknown) {
+          console.debug(
+            `GrepLogic: git grep failed: ${getErrorMessage(
+              gitError,
+            )}. Falling back...`,
+          );
+        }
+      }
+
+      // --- Strategy 2: System grep ---
+      const grepAvailable = await this.isCommandAvailable('grep');
+      if (grepAvailable) {
+        strategyUsed = 'system grep';
+        const grepArgs = ['-r', '-n', '-H', '-E'];
+        const commonExcludes = ['.git', 'node_modules', 'bower_components'];
+        commonExcludes.forEach((dir) => grepArgs.push(`--exclude-dir=${dir}`));
+        if (include) {
+          grepArgs.push(`--include=${include}`);
+        }
+        grepArgs.push(pattern);
+        grepArgs.push('.');
+
+        try {
+          const output = await new Promise<string>((resolve, reject) => {
+            const child = spawn('grep', grepArgs, {
+              cwd: absolutePath,
+              windowsHide: true,
+            });
+            const stdoutChunks: Buffer[] = [];
+            const stderrChunks: Buffer[] = [];
+
+            const onData = (chunk: Buffer) => stdoutChunks.push(chunk);
+            const onStderr = (chunk: Buffer) => {
+              const stderrStr = chunk.toString();
+              // Suppress common harmless stderr messages
+              if (
+                !stderrStr.includes('Permission denied') &&
+                !/grep:.*: Is a directory/i.test(stderrStr)
+              ) {
+                stderrChunks.push(chunk);
+              }
+            };
+            const onError = (err: Error) => {
+              cleanup();
+              reject(new Error(`Failed to start system grep: ${err.message}`));
+            };
+            const onClose = (code: number | null) => {
+              const stdoutData = Buffer.concat(stdoutChunks).toString('utf8');
+              const stderrData = Buffer.concat(stderrChunks)
+                .toString('utf8')
+                .trim();
+              cleanup();
+              if (code === 0) resolve(stdoutData);
+              else if (code === 1)
+                resolve(''); // No matches
+              else {
+                if (stderrData)
+                  reject(
+                    new Error(
+                      `System grep exited with code ${code}: ${stderrData}`,
+                    ),
+                  );
+                else resolve(''); // Exit code > 1 but no stderr, likely just suppressed errors
+              }
+            };
+
+            const cleanup = () => {
+              child.stdout.removeListener('data', onData);
+              child.stderr.removeListener('data', onStderr);
+              child.removeListener('error', onError);
+              child.removeListener('close', onClose);
+              if (child.connected) {
+                child.disconnect();
+              }
+            };
+
+            child.stdout.on('data', onData);
+            child.stderr.on('data', onStderr);
+            child.on('error', onError);
+            child.on('close', onClose);
+          });
+          return this.parseGrepOutput(output, absolutePath);
+        } catch (grepError: unknown) {
+          console.debug(
+            `GrepLogic: System grep failed: ${getErrorMessage(
+              grepError,
+            )}. Falling back...`,
+          );
+        }
+      }
+
+      // --- Strategy 3: Pure JavaScript Fallback ---
+      console.debug(
+        'GrepLogic: Falling back to JavaScript grep implementation.',
+      );
+      strategyUsed = 'javascript fallback';
+      const globPattern = include ? include : '**/*';
+
+      // Get the file discovery service to check ignore patterns
+      const fileDiscovery = this.config.getFileService();
+
+      // Basic ignore patterns
+      const ignorePatterns = [
+        '.git/**',
+        'node_modules/**',
+        'bower_components/**',
+        '.svn/**',
+        '.hg/**',
+        ...fileDiscovery.getGeminiIgnorePatterns(),
+      ]; // Use glob patterns for ignores here
+
+      const filesIterator = globStream(globPattern, {
+        cwd: absolutePath,
+        dot: true,
+        ignore: ignorePatterns,
+        absolute: true,
+        nodir: true,
+        signal: options.signal,
+      });
+
+      const regex = new RegExp(pattern, 'i');
+      const allMatches: GrepMatch[] = [];
+
+      for await (const filePath of filesIterator) {
+        const fileAbsolutePath = filePath as string;
+        try {
+          const content = await fsPromises.readFile(fileAbsolutePath, 'utf8');
+          const lines = content.split(/\r?\n/);
+          lines.forEach((line, index) => {
+            if (regex.test(line)) {
+              allMatches.push({
+                filePath:
+                  path.relative(absolutePath, fileAbsolutePath) ||
+                  path.basename(fileAbsolutePath),
+                lineNumber: index + 1,
+                line,
+              });
+            }
+          });
+        } catch (readError: unknown) {
+          // Ignore errors like permission denied or file gone during read
+          if (!isNodeError(readError) || readError.code !== 'ENOENT') {
+            console.debug(
+              `GrepLogic: Could not read/process ${fileAbsolutePath}: ${getErrorMessage(
+                readError,
+              )}`,
+            );
+          }
+        }
+      }
+
+      return allMatches;
+    } catch (error: unknown) {
+      console.error(
+        `GrepLogic: Error in performGrepSearch (Strategy: ${strategyUsed}): ${getErrorMessage(
+          error,
+        )}`,
+      );
+      throw error; // Re-throw
+    }
+  }
+}
+
+// --- GrepLogic Class ---
+
+/**
+ * Implementation of the Grep tool logic (moved from CLI)
+ */
+export class GrepTool extends BaseDeclarativeTool<GrepToolParams, ToolResult> {
+  static readonly Name = 'search_file_content'; // Keep static name
+
+  constructor(private readonly config: Config) {
+    super(
+      GrepTool.Name,
+      'SearchText',
+      'Searches for a regular expression pattern within the content of files in a specified directory (or current working directory). Can filter files by a glob pattern. Returns the lines containing matches, along with their file paths and line numbers.',
+      Kind.Search,
+      {
+        properties: {
+          pattern: {
+            description:
+              "The regular expression (regex) pattern to search for within file contents (e.g., 'function\\s+myFunction', 'import\\s+\\{.*\\}\\s+from\\s+.*').",
+            type: 'string',
+          },
+          path: {
+            description:
+              'Optional: The absolute path to the directory to search within. If omitted, searches the current working directory.',
+            type: 'string',
+          },
+          include: {
+            description:
+              "Optional: A glob pattern to filter which files are searched (e.g., '*.js', '*.{ts,tsx}', 'src/**'). If omitted, searches all files (respecting potential global ignores).",
+            type: 'string',
+          },
+          maxResults: {
+            description:
+              'Optional: Maximum number of matches to return to prevent context overflow (default: 20, max: 100). Use lower values for broad searches, higher for specific searches.',
+            type: 'number',
+            minimum: 1,
+            maximum: 100,
+          },
+        },
+        required: ['pattern'],
+        type: 'object',
+      },
+    );
+  }
+
+  /**
+   * Checks if a path is within the root directory and resolves it.
+   * @param relativePath Path relative to the root directory (or undefined for root).
+   * @returns The absolute path if valid and exists, or null if no path specified (to search all directories).
+   * @throws {Error} If path is outside root, doesn't exist, or isn't a directory.
+   */
+  private resolveAndValidatePath(relativePath?: string): string | null {
+    // If no path specified, return null to indicate searching all workspace directories
+    if (!relativePath) {
+      return null;
+    }
+
+    const targetPath = path.resolve(this.config.getTargetDir(), relativePath);
+
+    // Security Check: Ensure the resolved path is within workspace boundaries
+    const workspaceContext = this.config.getWorkspaceContext();
+    if (!workspaceContext.isPathWithinWorkspace(targetPath)) {
+      const directories = workspaceContext.getDirectories();
+      throw new Error(
+        `Path validation failed: Attempted path "${relativePath}" resolves outside the allowed workspace directories: ${directories.join(', ')}`,
+      );
+    }
+
+    // Check existence and type after resolving
+    try {
+      const stats = fs.statSync(targetPath);
+      if (!stats.isDirectory()) {
+        throw new Error(`Path is not a directory: ${targetPath}`);
+      }
+    } catch (error: unknown) {
+      if (isNodeError(error) && error.code !== 'ENOENT') {
+        throw new Error(`Path does not exist: ${targetPath}`);
+      }
+      throw new Error(
+        `Failed to access path stats for ${targetPath}: ${error}`,
+      );
+    }
+
+    return targetPath;
+  }
+
+  /**
+   * Validates the parameters for the tool
+   * @param params Parameters to validate
+   * @returns An error message string if invalid, null otherwise
+   */
+  protected override validateToolParamValues(
+    params: GrepToolParams,
+  ): string | null {
+    try {
+      new RegExp(params.pattern);
+    } catch (error) {
+      return `Invalid regular expression pattern provided: ${params.pattern}. Error: ${getErrorMessage(error)}`;
+    }
+
+    // Validate maxResults if provided
+    if (params.maxResults !== undefined) {
+      if (
+        !Number.isInteger(params.maxResults) ||
+        params.maxResults < 1 ||
+        params.maxResults > 100
+      ) {
+        return `maxResults must be an integer between 1 and 100, got: ${params.maxResults}`;
+      }
+    }
+
+    // Only validate path if one is provided
+    if (params.path) {
+      try {
+        this.resolveAndValidatePath(params.path);
+      } catch (error) {
+        return getErrorMessage(error);
+      }
+    }
+
+    return null; // Parameters are valid
+  }
+
+  protected createInvocation(
+    params: GrepToolParams,
+  ): ToolInvocation<GrepToolParams, ToolResult> {
+    return new GrepToolInvocation(this.config, params);
+  }
+}

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

@@ -0,0 +1,484 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import fs from 'fs';
+import path from 'path';
+
+vi.mock('fs', () => ({
+  default: {
+    statSync: vi.fn(),
+    readdirSync: vi.fn(),
+  },
+  statSync: vi.fn(),
+  readdirSync: vi.fn(),
+}));
+import { LSTool } from './ls.js';
+import { Config } from '../config/config.js';
+import { WorkspaceContext } from '../utils/workspaceContext.js';
+import { FileDiscoveryService } from '../services/fileDiscoveryService.js';
+
+describe('LSTool', () => {
+  let lsTool: LSTool;
+  let mockConfig: Config;
+  let mockWorkspaceContext: WorkspaceContext;
+  let mockFileService: FileDiscoveryService;
+  const mockPrimaryDir = '/home/user/project';
+  const mockSecondaryDir = '/home/user/other-project';
+
+  beforeEach(() => {
+    vi.resetAllMocks();
+
+    // Mock WorkspaceContext
+    mockWorkspaceContext = {
+      getDirectories: vi
+        .fn()
+        .mockReturnValue([mockPrimaryDir, mockSecondaryDir]),
+      isPathWithinWorkspace: vi
+        .fn()
+        .mockImplementation(
+          (path) =>
+            path.startsWith(mockPrimaryDir) ||
+            path.startsWith(mockSecondaryDir),
+        ),
+      addDirectory: vi.fn(),
+    } as unknown as WorkspaceContext;
+
+    // Mock FileService
+    mockFileService = {
+      shouldGitIgnoreFile: vi.fn().mockReturnValue(false),
+      shouldGeminiIgnoreFile: vi.fn().mockReturnValue(false),
+    } as unknown as FileDiscoveryService;
+
+    // Mock Config
+    mockConfig = {
+      getTargetDir: vi.fn().mockReturnValue(mockPrimaryDir),
+      getWorkspaceContext: vi.fn().mockReturnValue(mockWorkspaceContext),
+      getFileService: vi.fn().mockReturnValue(mockFileService),
+      getFileFilteringOptions: vi.fn().mockReturnValue({
+        respectGitIgnore: true,
+        respectGeminiIgnore: true,
+      }),
+    } as unknown as Config;
+
+    lsTool = new LSTool(mockConfig);
+  });
+
+  describe('parameter validation', () => {
+    it('should accept valid absolute paths within workspace', () => {
+      const params = {
+        path: '/home/user/project/src',
+      };
+      vi.mocked(fs.statSync).mockReturnValue({
+        isDirectory: () => true,
+      } as fs.Stats);
+      const invocation = lsTool.build(params);
+      expect(invocation).toBeDefined();
+    });
+
+    it('should reject relative paths', () => {
+      const params = {
+        path: './src',
+      };
+
+      expect(() => lsTool.build(params)).toThrow(
+        'Path must be absolute: ./src',
+      );
+    });
+
+    it('should reject paths outside workspace with clear error message', () => {
+      const params = {
+        path: '/etc/passwd',
+      };
+
+      expect(() => lsTool.build(params)).toThrow(
+        'Path must be within one of the workspace directories: /home/user/project, /home/user/other-project',
+      );
+    });
+
+    it('should accept paths in secondary workspace directory', () => {
+      const params = {
+        path: '/home/user/other-project/lib',
+      };
+      vi.mocked(fs.statSync).mockReturnValue({
+        isDirectory: () => true,
+      } as fs.Stats);
+      const invocation = lsTool.build(params);
+      expect(invocation).toBeDefined();
+    });
+  });
+
+  describe('execute', () => {
+    it('should list files in a directory', async () => {
+      const testPath = '/home/user/project/src';
+      const mockFiles = ['file1.ts', 'file2.ts', 'subdir'];
+      const mockStats = {
+        isDirectory: vi.fn(),
+        mtime: new Date(),
+        size: 1024,
+      };
+
+      vi.mocked(fs.statSync).mockImplementation((path: any) => {
+        const pathStr = path.toString();
+        if (pathStr === testPath) {
+          return { isDirectory: () => true } as fs.Stats;
+        }
+        // For individual files
+        if (pathStr.toString().endsWith('subdir')) {
+          return { ...mockStats, isDirectory: () => true, size: 0 } as fs.Stats;
+        }
+        return { ...mockStats, isDirectory: () => false } as fs.Stats;
+      });
+
+      vi.mocked(fs.readdirSync).mockReturnValue(mockFiles as any);
+
+      const invocation = lsTool.build({ path: testPath });
+      const result = await invocation.execute(new AbortController().signal);
+
+      expect(result.llmContent).toContain('[DIR] subdir');
+      expect(result.llmContent).toContain('file1.ts');
+      expect(result.llmContent).toContain('file2.ts');
+      expect(result.returnDisplay).toBe('Listed 3 item(s).');
+    });
+
+    it('should list files from secondary workspace directory', async () => {
+      const testPath = '/home/user/other-project/lib';
+      const mockFiles = ['module1.js', 'module2.js'];
+
+      vi.mocked(fs.statSync).mockImplementation((path: any) => {
+        if (path.toString() === testPath) {
+          return { isDirectory: () => true } as fs.Stats;
+        }
+        return {
+          isDirectory: () => false,
+          mtime: new Date(),
+          size: 2048,
+        } as fs.Stats;
+      });
+
+      vi.mocked(fs.readdirSync).mockReturnValue(mockFiles as any);
+
+      const invocation = lsTool.build({ path: testPath });
+      const result = await invocation.execute(new AbortController().signal);
+
+      expect(result.llmContent).toContain('module1.js');
+      expect(result.llmContent).toContain('module2.js');
+      expect(result.returnDisplay).toBe('Listed 2 item(s).');
+    });
+
+    it('should handle empty directories', async () => {
+      const testPath = '/home/user/project/empty';
+
+      vi.mocked(fs.statSync).mockReturnValue({
+        isDirectory: () => true,
+      } as fs.Stats);
+      vi.mocked(fs.readdirSync).mockReturnValue([]);
+
+      const invocation = lsTool.build({ path: testPath });
+      const result = await invocation.execute(new AbortController().signal);
+
+      expect(result.llmContent).toBe(
+        'Directory /home/user/project/empty is empty.',
+      );
+      expect(result.returnDisplay).toBe('Directory is empty.');
+    });
+
+    it('should respect ignore patterns', async () => {
+      const testPath = '/home/user/project/src';
+      const mockFiles = ['test.js', 'test.spec.js', 'index.js'];
+
+      vi.mocked(fs.statSync).mockImplementation((path: any) => {
+        const pathStr = path.toString();
+        if (pathStr === testPath) {
+          return { isDirectory: () => true } as fs.Stats;
+        }
+        return {
+          isDirectory: () => false,
+          mtime: new Date(),
+          size: 1024,
+        } as fs.Stats;
+      });
+      vi.mocked(fs.readdirSync).mockReturnValue(mockFiles as any);
+
+      const invocation = lsTool.build({
+        path: testPath,
+        ignore: ['*.spec.js'],
+      });
+      const result = await invocation.execute(new AbortController().signal);
+
+      expect(result.llmContent).toContain('test.js');
+      expect(result.llmContent).toContain('index.js');
+      expect(result.llmContent).not.toContain('test.spec.js');
+      expect(result.returnDisplay).toBe('Listed 2 item(s).');
+    });
+
+    it('should respect gitignore patterns', async () => {
+      const testPath = '/home/user/project/src';
+      const mockFiles = ['file1.js', 'file2.js', 'ignored.js'];
+
+      vi.mocked(fs.statSync).mockImplementation((path: any) => {
+        const pathStr = path.toString();
+        if (pathStr === testPath) {
+          return { isDirectory: () => true } as fs.Stats;
+        }
+        return {
+          isDirectory: () => false,
+          mtime: new Date(),
+          size: 1024,
+        } as fs.Stats;
+      });
+      vi.mocked(fs.readdirSync).mockReturnValue(mockFiles as any);
+      (mockFileService.shouldGitIgnoreFile as any).mockImplementation(
+        (path: string) => path.includes('ignored.js'),
+      );
+
+      const invocation = lsTool.build({ path: testPath });
+      const result = await invocation.execute(new AbortController().signal);
+
+      expect(result.llmContent).toContain('file1.js');
+      expect(result.llmContent).toContain('file2.js');
+      expect(result.llmContent).not.toContain('ignored.js');
+      expect(result.returnDisplay).toBe('Listed 2 item(s). (1 git-ignored)');
+    });
+
+    it('should respect geminiignore patterns', async () => {
+      const testPath = '/home/user/project/src';
+      const mockFiles = ['file1.js', 'file2.js', 'private.js'];
+
+      vi.mocked(fs.statSync).mockImplementation((path: any) => {
+        const pathStr = path.toString();
+        if (pathStr === testPath) {
+          return { isDirectory: () => true } as fs.Stats;
+        }
+        return {
+          isDirectory: () => false,
+          mtime: new Date(),
+          size: 1024,
+        } as fs.Stats;
+      });
+      vi.mocked(fs.readdirSync).mockReturnValue(mockFiles as any);
+      (mockFileService.shouldGeminiIgnoreFile as any).mockImplementation(
+        (path: string) => path.includes('private.js'),
+      );
+
+      const invocation = lsTool.build({ path: testPath });
+      const result = await invocation.execute(new AbortController().signal);
+
+      expect(result.llmContent).toContain('file1.js');
+      expect(result.llmContent).toContain('file2.js');
+      expect(result.llmContent).not.toContain('private.js');
+      expect(result.returnDisplay).toBe('Listed 2 item(s). (1 gemini-ignored)');
+    });
+
+    it('should handle non-directory paths', async () => {
+      const testPath = '/home/user/project/file.txt';
+
+      vi.mocked(fs.statSync).mockReturnValue({
+        isDirectory: () => false,
+      } as fs.Stats);
+
+      const invocation = lsTool.build({ path: testPath });
+      const result = await invocation.execute(new AbortController().signal);
+
+      expect(result.llmContent).toContain('Path is not a directory');
+      expect(result.returnDisplay).toBe('Error: Path is not a directory.');
+    });
+
+    it('should handle non-existent paths', async () => {
+      const testPath = '/home/user/project/does-not-exist';
+
+      vi.mocked(fs.statSync).mockImplementation(() => {
+        throw new Error('ENOENT: no such file or directory');
+      });
+
+      const invocation = lsTool.build({ path: testPath });
+      const result = await invocation.execute(new AbortController().signal);
+
+      expect(result.llmContent).toContain('Error listing directory');
+      expect(result.returnDisplay).toBe('Error: Failed to list directory.');
+    });
+
+    it('should sort directories first, then files alphabetically', async () => {
+      const testPath = '/home/user/project/src';
+      const mockFiles = ['z-file.ts', 'a-dir', 'b-file.ts', 'c-dir'];
+
+      vi.mocked(fs.statSync).mockImplementation((path: any) => {
+        if (path.toString() === testPath) {
+          return { isDirectory: () => true } as fs.Stats;
+        }
+        if (path.toString().endsWith('-dir')) {
+          return {
+            isDirectory: () => true,
+            mtime: new Date(),
+            size: 0,
+          } as fs.Stats;
+        }
+        return {
+          isDirectory: () => false,
+          mtime: new Date(),
+          size: 1024,
+        } as fs.Stats;
+      });
+
+      vi.mocked(fs.readdirSync).mockReturnValue(mockFiles as any);
+
+      const invocation = lsTool.build({ path: testPath });
+      const result = await invocation.execute(new AbortController().signal);
+
+      const lines = (
+        typeof result.llmContent === 'string' ? result.llmContent : ''
+      ).split('\n');
+      const entries = lines.slice(1).filter((line: string) => line.trim()); // Skip header
+      expect(entries[0]).toBe('[DIR] a-dir');
+      expect(entries[1]).toBe('[DIR] c-dir');
+      expect(entries[2]).toBe('b-file.ts');
+      expect(entries[3]).toBe('z-file.ts');
+    });
+
+    it('should handle permission errors gracefully', async () => {
+      const testPath = '/home/user/project/restricted';
+
+      vi.mocked(fs.statSync).mockReturnValue({
+        isDirectory: () => true,
+      } as fs.Stats);
+      vi.mocked(fs.readdirSync).mockImplementation(() => {
+        throw new Error('EACCES: permission denied');
+      });
+
+      const invocation = lsTool.build({ path: testPath });
+      const result = await invocation.execute(new AbortController().signal);
+
+      expect(result.llmContent).toContain('Error listing directory');
+      expect(result.llmContent).toContain('permission denied');
+      expect(result.returnDisplay).toBe('Error: Failed to list directory.');
+    });
+
+    it('should throw for invalid params at build time', async () => {
+      expect(() => lsTool.build({ path: '../outside' })).toThrow(
+        'Path must be absolute: ../outside',
+      );
+    });
+
+    it('should handle errors accessing individual files during listing', async () => {
+      const testPath = '/home/user/project/src';
+      const mockFiles = ['accessible.ts', 'inaccessible.ts'];
+
+      vi.mocked(fs.statSync).mockImplementation((path: any) => {
+        if (path.toString() === testPath) {
+          return { isDirectory: () => true } as fs.Stats;
+        }
+        if (path.toString().endsWith('inaccessible.ts')) {
+          throw new Error('EACCES: permission denied');
+        }
+        return {
+          isDirectory: () => false,
+          mtime: new Date(),
+          size: 1024,
+        } as fs.Stats;
+      });
+
+      vi.mocked(fs.readdirSync).mockReturnValue(mockFiles as any);
+
+      // Spy on console.error to verify it's called
+      const consoleErrorSpy = vi
+        .spyOn(console, 'error')
+        .mockImplementation(() => {});
+
+      const invocation = lsTool.build({ path: testPath });
+      const result = await invocation.execute(new AbortController().signal);
+
+      // Should still list the accessible file
+      expect(result.llmContent).toContain('accessible.ts');
+      expect(result.llmContent).not.toContain('inaccessible.ts');
+      expect(result.returnDisplay).toBe('Listed 1 item(s).');
+
+      // Verify error was logged
+      expect(consoleErrorSpy).toHaveBeenCalledWith(
+        expect.stringContaining('Error accessing'),
+      );
+
+      consoleErrorSpy.mockRestore();
+    });
+  });
+
+  describe('getDescription', () => {
+    it('should return shortened relative path', () => {
+      const params = {
+        path: `${mockPrimaryDir}/deeply/nested/directory`,
+      };
+      vi.mocked(fs.statSync).mockReturnValue({
+        isDirectory: () => true,
+      } as fs.Stats);
+      const invocation = lsTool.build(params);
+      const description = invocation.getDescription();
+      expect(description).toBe(path.join('deeply', 'nested', 'directory'));
+    });
+
+    it('should handle paths in secondary workspace', () => {
+      const params = {
+        path: `${mockSecondaryDir}/lib`,
+      };
+      vi.mocked(fs.statSync).mockReturnValue({
+        isDirectory: () => true,
+      } as fs.Stats);
+      const invocation = lsTool.build(params);
+      const description = invocation.getDescription();
+      expect(description).toBe(path.join('..', 'other-project', 'lib'));
+    });
+  });
+
+  describe('workspace boundary validation', () => {
+    it('should accept paths in primary workspace directory', () => {
+      const params = { path: `${mockPrimaryDir}/src` };
+      vi.mocked(fs.statSync).mockReturnValue({
+        isDirectory: () => true,
+      } as fs.Stats);
+      expect(lsTool.build(params)).toBeDefined();
+    });
+
+    it('should accept paths in secondary workspace directory', () => {
+      const params = { path: `${mockSecondaryDir}/lib` };
+      vi.mocked(fs.statSync).mockReturnValue({
+        isDirectory: () => true,
+      } as fs.Stats);
+      expect(lsTool.build(params)).toBeDefined();
+    });
+
+    it('should reject paths outside all workspace directories', () => {
+      const params = { path: '/etc/passwd' };
+      expect(() => lsTool.build(params)).toThrow(
+        'Path must be within one of the workspace directories',
+      );
+    });
+
+    it('should list files from secondary workspace directory', async () => {
+      const testPath = `${mockSecondaryDir}/tests`;
+      const mockFiles = ['test1.spec.ts', 'test2.spec.ts'];
+
+      vi.mocked(fs.statSync).mockImplementation((path: any) => {
+        if (path.toString() === testPath) {
+          return { isDirectory: () => true } as fs.Stats;
+        }
+        return {
+          isDirectory: () => false,
+          mtime: new Date(),
+          size: 512,
+        } as fs.Stats;
+      });
+
+      vi.mocked(fs.readdirSync).mockReturnValue(mockFiles as any);
+
+      const invocation = lsTool.build({ path: testPath });
+      const result = await invocation.execute(new AbortController().signal);
+
+      expect(result.llmContent).toContain('test1.spec.ts');
+      expect(result.llmContent).toContain('test2.spec.ts');
+      expect(result.returnDisplay).toBe('Listed 2 item(s).');
+    });
+  });
+});

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

@@ -0,0 +1,338 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import fs from 'fs';
+import path from 'path';
+import {
+  BaseDeclarativeTool,
+  BaseToolInvocation,
+  Kind,
+  ToolInvocation,
+  ToolResult,
+} from './tools.js';
+import { makeRelative, shortenPath } from '../utils/paths.js';
+import { Config, DEFAULT_FILE_FILTERING_OPTIONS } from '../config/config.js';
+
+/**
+ * Parameters for the LS tool
+ */
+export interface LSToolParams {
+  /**
+   * The absolute path to the directory to list
+   */
+  path: string;
+
+  /**
+   * Array of glob patterns to ignore (optional)
+   */
+  ignore?: string[];
+
+  /**
+   * Whether to respect .gitignore and .geminiignore patterns (optional, defaults to true)
+   */
+  file_filtering_options?: {
+    respect_git_ignore?: boolean;
+    respect_gemini_ignore?: boolean;
+  };
+}
+
+/**
+ * File entry returned by LS tool
+ */
+export interface FileEntry {
+  /**
+   * Name of the file or directory
+   */
+  name: string;
+
+  /**
+   * Absolute path to the file or directory
+   */
+  path: string;
+
+  /**
+   * Whether this entry is a directory
+   */
+  isDirectory: boolean;
+
+  /**
+   * Size of the file in bytes (0 for directories)
+   */
+  size: number;
+
+  /**
+   * Last modified timestamp
+   */
+  modifiedTime: Date;
+}
+
+class LSToolInvocation extends BaseToolInvocation<LSToolParams, ToolResult> {
+  constructor(
+    private readonly config: Config,
+    params: LSToolParams,
+  ) {
+    super(params);
+  }
+
+  /**
+   * Checks if a filename matches any of the ignore patterns
+   * @param filename Filename to check
+   * @param patterns Array of glob patterns to check against
+   * @returns True if the filename should be ignored
+   */
+  private shouldIgnore(filename: string, patterns?: string[]): boolean {
+    if (!patterns || patterns.length === 0) {
+      return false;
+    }
+    for (const pattern of patterns) {
+      // Convert glob pattern to RegExp
+      const regexPattern = pattern
+        .replace(/[.+^${}()|[\]\\]/g, '\\$&')
+        .replace(/\*/g, '.*')
+        .replace(/\?/g, '.');
+      const regex = new RegExp(`^${regexPattern}$`);
+      if (regex.test(filename)) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  /**
+   * Gets a description of the file reading operation
+   * @returns A string describing the file being read
+   */
+  getDescription(): string {
+    const relativePath = makeRelative(
+      this.params.path,
+      this.config.getTargetDir(),
+    );
+    return shortenPath(relativePath);
+  }
+
+  // Helper for consistent error formatting
+  private errorResult(llmContent: string, returnDisplay: string): ToolResult {
+    return {
+      llmContent,
+      // Keep returnDisplay simpler in core logic
+      returnDisplay: `Error: ${returnDisplay}`,
+    };
+  }
+
+  /**
+   * Executes the LS operation with the given parameters
+   * @returns Result of the LS operation
+   */
+  async execute(_signal: AbortSignal): Promise<ToolResult> {
+    try {
+      const stats = fs.statSync(this.params.path);
+      if (!stats) {
+        // fs.statSync throws on non-existence, so this check might be redundant
+        // but keeping for clarity. Error message adjusted.
+        return this.errorResult(
+          `Error: Directory not found or inaccessible: ${this.params.path}`,
+          `Directory not found or inaccessible.`,
+        );
+      }
+      if (!stats.isDirectory()) {
+        return this.errorResult(
+          `Error: Path is not a directory: ${this.params.path}`,
+          `Path is not a directory.`,
+        );
+      }
+
+      const files = fs.readdirSync(this.params.path);
+
+      const defaultFileIgnores =
+        this.config.getFileFilteringOptions() ?? DEFAULT_FILE_FILTERING_OPTIONS;
+
+      const fileFilteringOptions = {
+        respectGitIgnore:
+          this.params.file_filtering_options?.respect_git_ignore ??
+          defaultFileIgnores.respectGitIgnore,
+        respectGeminiIgnore:
+          this.params.file_filtering_options?.respect_gemini_ignore ??
+          defaultFileIgnores.respectGeminiIgnore,
+      };
+
+      // Get centralized file discovery service
+
+      const fileDiscovery = this.config.getFileService();
+
+      const entries: FileEntry[] = [];
+      let gitIgnoredCount = 0;
+      let geminiIgnoredCount = 0;
+
+      if (files.length === 0) {
+        // Changed error message to be more neutral for LLM
+        return {
+          llmContent: `Directory ${this.params.path} is empty.`,
+          returnDisplay: `Directory is empty.`,
+        };
+      }
+
+      for (const file of files) {
+        if (this.shouldIgnore(file, this.params.ignore)) {
+          continue;
+        }
+
+        const fullPath = path.join(this.params.path, file);
+        const relativePath = path.relative(
+          this.config.getTargetDir(),
+          fullPath,
+        );
+
+        // Check if this file should be ignored based on git or gemini ignore rules
+        if (
+          fileFilteringOptions.respectGitIgnore &&
+          fileDiscovery.shouldGitIgnoreFile(relativePath)
+        ) {
+          gitIgnoredCount++;
+          continue;
+        }
+        if (
+          fileFilteringOptions.respectGeminiIgnore &&
+          fileDiscovery.shouldGeminiIgnoreFile(relativePath)
+        ) {
+          geminiIgnoredCount++;
+          continue;
+        }
+
+        try {
+          const stats = fs.statSync(fullPath);
+          const isDir = stats.isDirectory();
+          entries.push({
+            name: file,
+            path: fullPath,
+            isDirectory: isDir,
+            size: isDir ? 0 : stats.size,
+            modifiedTime: stats.mtime,
+          });
+        } catch (error) {
+          // Log error internally but don't fail the whole listing
+          console.error(`Error accessing ${fullPath}: ${error}`);
+        }
+      }
+
+      // Sort entries (directories first, then alphabetically)
+      entries.sort((a, b) => {
+        if (a.isDirectory && !b.isDirectory) return -1;
+        if (!a.isDirectory && b.isDirectory) return 1;
+        return a.name.localeCompare(b.name);
+      });
+
+      // Create formatted content for LLM
+      const directoryContent = entries
+        .map((entry) => `${entry.isDirectory ? '[DIR] ' : ''}${entry.name}`)
+        .join('\n');
+
+      let resultMessage = `Directory listing for ${this.params.path}:\n${directoryContent}`;
+      const ignoredMessages = [];
+      if (gitIgnoredCount > 0) {
+        ignoredMessages.push(`${gitIgnoredCount} git-ignored`);
+      }
+      if (geminiIgnoredCount > 0) {
+        ignoredMessages.push(`${geminiIgnoredCount} gemini-ignored`);
+      }
+
+      if (ignoredMessages.length > 0) {
+        resultMessage += `\n\n(${ignoredMessages.join(', ')})`;
+      }
+
+      let displayMessage = `Listed ${entries.length} item(s).`;
+      if (ignoredMessages.length > 0) {
+        displayMessage += ` (${ignoredMessages.join(', ')})`;
+      }
+
+      return {
+        llmContent: resultMessage,
+        returnDisplay: displayMessage,
+      };
+    } catch (error) {
+      const errorMsg = `Error listing directory: ${error instanceof Error ? error.message : String(error)}`;
+      return this.errorResult(errorMsg, 'Failed to list directory.');
+    }
+  }
+}
+
+/**
+ * Implementation of the LS tool logic
+ */
+export class LSTool extends BaseDeclarativeTool<LSToolParams, ToolResult> {
+  static readonly Name = 'list_directory';
+
+  constructor(private config: Config) {
+    super(
+      LSTool.Name,
+      'ReadFolder',
+      'Lists the names of files and subdirectories directly within a specified directory path. Can optionally ignore entries matching provided glob patterns.',
+      Kind.Search,
+      {
+        properties: {
+          path: {
+            description:
+              'The absolute path to the directory to list (must be absolute, not relative)',
+            type: 'string',
+          },
+          ignore: {
+            description: 'List of glob patterns to ignore',
+            items: {
+              type: 'string',
+            },
+            type: 'array',
+          },
+          file_filtering_options: {
+            description:
+              'Optional: Whether to respect ignore patterns from .gitignore or .geminiignore',
+            type: 'object',
+            properties: {
+              respect_git_ignore: {
+                description:
+                  'Optional: Whether to respect .gitignore patterns when listing files. Only available in git repositories. Defaults to true.',
+                type: 'boolean',
+              },
+              respect_gemini_ignore: {
+                description:
+                  'Optional: Whether to respect .geminiignore patterns when listing files. Defaults to true.',
+                type: 'boolean',
+              },
+            },
+          },
+        },
+        required: ['path'],
+        type: 'object',
+      },
+    );
+  }
+
+  /**
+   * Validates the parameters for the tool
+   * @param params Parameters to validate
+   * @returns An error message string if invalid, null otherwise
+   */
+  protected override validateToolParamValues(
+    params: LSToolParams,
+  ): string | null {
+    if (!path.isAbsolute(params.path)) {
+      return `Path must be absolute: ${params.path}`;
+    }
+
+    const workspaceContext = this.config.getWorkspaceContext();
+    if (!workspaceContext.isPathWithinWorkspace(params.path)) {
+      const directories = workspaceContext.getDirectories();
+      return `Path must be within one of the workspace directories: ${directories.join(
+        ', ',
+      )}`;
+    }
+    return null;
+  }
+
+  protected createInvocation(
+    params: LSToolParams,
+  ): ToolInvocation<LSToolParams, ToolResult> {
+    return new LSToolInvocation(this.config, params);
+  }
+}

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

@@ -0,0 +1,54 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import { McpClientManager } from './mcp-client-manager.js';
+import { McpClient } from './mcp-client.js';
+import { ToolRegistry } from './tool-registry.js';
+import { PromptRegistry } from '../prompts/prompt-registry.js';
+import { WorkspaceContext } from '../utils/workspaceContext.js';
+
+vi.mock('./mcp-client.js', async () => {
+  const originalModule = await vi.importActual('./mcp-client.js');
+  return {
+    ...originalModule,
+    McpClient: vi.fn(),
+    populateMcpServerCommand: vi.fn(() => ({
+      'test-server': {},
+    })),
+  };
+});
+
+describe('McpClientManager', () => {
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it('should discover tools from all servers', async () => {
+    const mockedMcpClient = {
+      connect: vi.fn(),
+      discover: vi.fn(),
+      disconnect: vi.fn(),
+      getStatus: vi.fn(),
+    };
+    vi.mocked(McpClient).mockReturnValue(
+      mockedMcpClient as unknown as McpClient,
+    );
+    const manager = new McpClientManager(
+      {
+        'test-server': {},
+      },
+      '',
+      {} as ToolRegistry,
+      {} as PromptRegistry,
+      false,
+      {} as WorkspaceContext,
+    );
+    await manager.discoverAllMcpTools();
+    expect(mockedMcpClient.connect).toHaveBeenCalledOnce();
+    expect(mockedMcpClient.discover).toHaveBeenCalledOnce();
+  });
+});

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

@@ -0,0 +1,115 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { MCPServerConfig } from '../config/config.js';
+import { ToolRegistry } from './tool-registry.js';
+import { PromptRegistry } from '../prompts/prompt-registry.js';
+import {
+  McpClient,
+  MCPDiscoveryState,
+  populateMcpServerCommand,
+} from './mcp-client.js';
+import { getErrorMessage } from '../utils/errors.js';
+import { WorkspaceContext } from '../utils/workspaceContext.js';
+
+/**
+ * Manages the lifecycle of multiple MCP clients, including local child processes.
+ * This class is responsible for starting, stopping, and discovering tools from
+ * a collection of MCP servers defined in the configuration.
+ */
+export class McpClientManager {
+  private clients: Map<string, McpClient> = new Map();
+  private readonly mcpServers: Record<string, MCPServerConfig>;
+  private readonly mcpServerCommand: string | undefined;
+  private readonly toolRegistry: ToolRegistry;
+  private readonly promptRegistry: PromptRegistry;
+  private readonly debugMode: boolean;
+  private readonly workspaceContext: WorkspaceContext;
+  private discoveryState: MCPDiscoveryState = MCPDiscoveryState.NOT_STARTED;
+
+  constructor(
+    mcpServers: Record<string, MCPServerConfig>,
+    mcpServerCommand: string | undefined,
+    toolRegistry: ToolRegistry,
+    promptRegistry: PromptRegistry,
+    debugMode: boolean,
+    workspaceContext: WorkspaceContext,
+  ) {
+    this.mcpServers = mcpServers;
+    this.mcpServerCommand = mcpServerCommand;
+    this.toolRegistry = toolRegistry;
+    this.promptRegistry = promptRegistry;
+    this.debugMode = debugMode;
+    this.workspaceContext = workspaceContext;
+  }
+
+  /**
+   * Initiates the tool discovery process for all configured MCP servers.
+   * It connects to each server, discovers its available tools, and registers
+   * them with the `ToolRegistry`.
+   */
+  async discoverAllMcpTools(): Promise<void> {
+    await this.stop();
+    this.discoveryState = MCPDiscoveryState.IN_PROGRESS;
+    const servers = populateMcpServerCommand(
+      this.mcpServers,
+      this.mcpServerCommand,
+    );
+
+    const discoveryPromises = Object.entries(servers).map(
+      async ([name, config]) => {
+        const client = new McpClient(
+          name,
+          config,
+          this.toolRegistry,
+          this.promptRegistry,
+          this.workspaceContext,
+          this.debugMode,
+        );
+        this.clients.set(name, client);
+        try {
+          await client.connect();
+          await client.discover();
+        } catch (error) {
+          // Log the error but don't let a single failed server stop the others
+          console.error(
+            `Error during discovery for server '${name}': ${getErrorMessage(
+              error,
+            )}`,
+          );
+        }
+      },
+    );
+
+    await Promise.all(discoveryPromises);
+    this.discoveryState = MCPDiscoveryState.COMPLETED;
+  }
+
+  /**
+   * Stops all running local MCP servers and closes all client connections.
+   * This is the cleanup method to be called on application exit.
+   */
+  async stop(): Promise<void> {
+    const disconnectionPromises = Array.from(this.clients.entries()).map(
+      async ([name, client]) => {
+        try {
+          await client.disconnect();
+        } catch (error) {
+          console.error(
+            `Error stopping client '${name}': ${getErrorMessage(error)}`,
+          );
+        }
+      },
+    );
+
+    await Promise.all(disconnectionPromises);
+    this.clients.clear();
+  }
+
+  getDiscoveryState(): MCPDiscoveryState {
+    return this.discoveryState;
+  }
+}

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

@@ -0,0 +1,569 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
+import {
+  populateMcpServerCommand,
+  createTransport,
+  isEnabled,
+  hasValidTypes,
+  McpClient,
+} from './mcp-client.js';
+import { SSEClientTransport } from '@modelcontextprotocol/sdk/client/sse.js';
+import * as SdkClientStdioLib from '@modelcontextprotocol/sdk/client/stdio.js';
+import * as ClientLib from '@modelcontextprotocol/sdk/client/index.js';
+import * as GenAiLib from '@google/genai';
+import { GoogleCredentialProvider } from '../mcp/google-auth-provider.js';
+import { AuthProviderType } from '../config/config.js';
+import { PromptRegistry } from '../prompts/prompt-registry.js';
+import { ToolRegistry } from './tool-registry.js';
+import { WorkspaceContext } from '../utils/workspaceContext.js';
+
+vi.mock('@modelcontextprotocol/sdk/client/stdio.js');
+vi.mock('@modelcontextprotocol/sdk/client/index.js');
+vi.mock('@google/genai');
+vi.mock('../mcp/oauth-provider.js');
+vi.mock('../mcp/oauth-token-storage.js');
+
+describe('mcp-client', () => {
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  describe('McpClient', () => {
+    it('should discover tools', async () => {
+      const mockedClient = {
+        connect: vi.fn(),
+        discover: vi.fn(),
+        disconnect: vi.fn(),
+        getStatus: vi.fn(),
+        registerCapabilities: vi.fn(),
+        setRequestHandler: vi.fn(),
+      };
+      vi.mocked(ClientLib.Client).mockReturnValue(
+        mockedClient as unknown as ClientLib.Client,
+      );
+      vi.spyOn(SdkClientStdioLib, 'StdioClientTransport').mockReturnValue(
+        {} as SdkClientStdioLib.StdioClientTransport,
+      );
+      const mockedMcpToTool = vi.mocked(GenAiLib.mcpToTool).mockReturnValue({
+        tool: () => ({
+          functionDeclarations: [
+            {
+              name: 'testFunction',
+            },
+          ],
+        }),
+      } as unknown as GenAiLib.CallableTool);
+      const mockedToolRegistry = {
+        registerTool: vi.fn(),
+      } as unknown as ToolRegistry;
+      const client = new McpClient(
+        'test-server',
+        {
+          command: 'test-command',
+        },
+        mockedToolRegistry,
+        {} as PromptRegistry,
+        {} as WorkspaceContext,
+        false,
+      );
+      await client.connect();
+      await client.discover();
+      expect(mockedMcpToTool).toHaveBeenCalledOnce();
+    });
+
+    it('should skip tools if a parameter is missing a type', async () => {
+      const consoleWarnSpy = vi
+        .spyOn(console, 'warn')
+        .mockImplementation(() => {});
+      const mockedClient = {
+        connect: vi.fn(),
+        discover: vi.fn(),
+        disconnect: vi.fn(),
+        getStatus: vi.fn(),
+        registerCapabilities: vi.fn(),
+        setRequestHandler: vi.fn(),
+        tool: vi.fn(),
+      };
+      vi.mocked(ClientLib.Client).mockReturnValue(
+        mockedClient as unknown as ClientLib.Client,
+      );
+      vi.spyOn(SdkClientStdioLib, 'StdioClientTransport').mockReturnValue(
+        {} as SdkClientStdioLib.StdioClientTransport,
+      );
+      vi.mocked(GenAiLib.mcpToTool).mockReturnValue({
+        tool: () =>
+          Promise.resolve({
+            functionDeclarations: [
+              {
+                name: 'validTool',
+                parametersJsonSchema: {
+                  type: 'object',
+                  properties: {
+                    param1: { type: 'string' },
+                  },
+                },
+              },
+              {
+                name: 'invalidTool',
+                parametersJsonSchema: {
+                  type: 'object',
+                  properties: {
+                    param1: { description: 'a param with no type' },
+                  },
+                },
+              },
+            ],
+          }),
+      } as unknown as GenAiLib.CallableTool);
+      const mockedToolRegistry = {
+        registerTool: vi.fn(),
+      } as unknown as ToolRegistry;
+      const client = new McpClient(
+        'test-server',
+        {
+          command: 'test-command',
+        },
+        mockedToolRegistry,
+        {} as PromptRegistry,
+        {} as WorkspaceContext,
+        false,
+      );
+      await client.connect();
+      await client.discover();
+      expect(mockedToolRegistry.registerTool).toHaveBeenCalledOnce();
+      expect(consoleWarnSpy).toHaveBeenCalledOnce();
+      expect(consoleWarnSpy).toHaveBeenCalledWith(
+        `Skipping tool 'invalidTool' from MCP server 'test-server' because it has ` +
+          `missing types in its parameter schema. Please file an issue with the owner of the MCP server.`,
+      );
+      consoleWarnSpy.mockRestore();
+    });
+
+    it('should handle errors when discovering prompts', async () => {
+      const consoleErrorSpy = vi
+        .spyOn(console, 'error')
+        .mockImplementation(() => {});
+      const mockedClient = {
+        connect: vi.fn(),
+        discover: vi.fn(),
+        disconnect: vi.fn(),
+        getStatus: vi.fn(),
+        registerCapabilities: vi.fn(),
+        setRequestHandler: vi.fn(),
+        getServerCapabilities: vi.fn().mockReturnValue({ prompts: {} }),
+        request: vi.fn().mockRejectedValue(new Error('Test error')),
+      };
+      vi.mocked(ClientLib.Client).mockReturnValue(
+        mockedClient as unknown as ClientLib.Client,
+      );
+      vi.spyOn(SdkClientStdioLib, 'StdioClientTransport').mockReturnValue(
+        {} as SdkClientStdioLib.StdioClientTransport,
+      );
+      vi.mocked(GenAiLib.mcpToTool).mockReturnValue({
+        tool: () => Promise.resolve({ functionDeclarations: [] }),
+      } as unknown as GenAiLib.CallableTool);
+      const client = new McpClient(
+        'test-server',
+        {
+          command: 'test-command',
+        },
+        {} as ToolRegistry,
+        {} as PromptRegistry,
+        {} as WorkspaceContext,
+        false,
+      );
+      await client.connect();
+      await expect(client.discover()).rejects.toThrow(
+        'No prompts or tools found on the server.',
+      );
+      expect(consoleErrorSpy).toHaveBeenCalledWith(
+        `Error discovering prompts from test-server: Test error`,
+      );
+      consoleErrorSpy.mockRestore();
+    });
+  });
+  describe('appendMcpServerCommand', () => {
+    it('should do nothing if no MCP servers or command are configured', () => {
+      const out = populateMcpServerCommand({}, undefined);
+      expect(out).toEqual({});
+    });
+
+    it('should discover tools via mcpServerCommand', () => {
+      const commandString = 'command --arg1 value1';
+      const out = populateMcpServerCommand({}, commandString);
+      expect(out).toEqual({
+        mcp: {
+          command: 'command',
+          args: ['--arg1', 'value1'],
+        },
+      });
+    });
+
+    it('should handle error if mcpServerCommand parsing fails', () => {
+      expect(() => populateMcpServerCommand({}, 'derp && herp')).toThrowError();
+    });
+  });
+
+  describe('createTransport', () => {
+    describe('should connect via httpUrl', () => {
+      it('without headers', async () => {
+        const transport = await createTransport(
+          'test-server',
+          {
+            httpUrl: 'http://test-server',
+          },
+          false,
+        );
+
+        expect(transport).toEqual(
+          new StreamableHTTPClientTransport(new URL('http://test-server'), {}),
+        );
+      });
+
+      it('with headers', async () => {
+        const transport = await createTransport(
+          'test-server',
+          {
+            httpUrl: 'http://test-server',
+            headers: { Authorization: 'derp' },
+          },
+          false,
+        );
+
+        expect(transport).toEqual(
+          new StreamableHTTPClientTransport(new URL('http://test-server'), {
+            requestInit: {
+              headers: { Authorization: 'derp' },
+            },
+          }),
+        );
+      });
+    });
+
+    describe('should connect via url', () => {
+      it('without headers', async () => {
+        const transport = await createTransport(
+          'test-server',
+          {
+            url: 'http://test-server',
+          },
+          false,
+        );
+        expect(transport).toEqual(
+          new SSEClientTransport(new URL('http://test-server'), {}),
+        );
+      });
+
+      it('with headers', async () => {
+        const transport = await createTransport(
+          'test-server',
+          {
+            url: 'http://test-server',
+            headers: { Authorization: 'derp' },
+          },
+          false,
+        );
+
+        expect(transport).toEqual(
+          new SSEClientTransport(new URL('http://test-server'), {
+            requestInit: {
+              headers: { Authorization: 'derp' },
+            },
+          }),
+        );
+      });
+    });
+
+    it('should connect via command', async () => {
+      const mockedTransport = vi
+        .spyOn(SdkClientStdioLib, 'StdioClientTransport')
+        .mockReturnValue({} as SdkClientStdioLib.StdioClientTransport);
+
+      await createTransport(
+        'test-server',
+        {
+          command: 'test-command',
+          args: ['--foo', 'bar'],
+          env: { FOO: 'bar' },
+          cwd: 'test/cwd',
+        },
+        false,
+      );
+
+      expect(mockedTransport).toHaveBeenCalledWith({
+        command: 'test-command',
+        args: ['--foo', 'bar'],
+        cwd: 'test/cwd',
+        env: { ...process.env, FOO: 'bar' },
+        stderr: 'pipe',
+      });
+    });
+
+    describe('useGoogleCredentialProvider', () => {
+      it('should use GoogleCredentialProvider when specified', async () => {
+        const transport = await createTransport(
+          'test-server',
+          {
+            httpUrl: 'http://test.googleapis.com',
+            authProviderType: AuthProviderType.GOOGLE_CREDENTIALS,
+            oauth: {
+              scopes: ['scope1'],
+            },
+          },
+          false,
+        );
+
+        expect(transport).toBeInstanceOf(StreamableHTTPClientTransport);
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const authProvider = (transport as any)._authProvider;
+        expect(authProvider).toBeInstanceOf(GoogleCredentialProvider);
+      });
+
+      it('should use GoogleCredentialProvider with SSE transport', async () => {
+        const transport = await createTransport(
+          'test-server',
+          {
+            url: 'http://test.googleapis.com',
+            authProviderType: AuthProviderType.GOOGLE_CREDENTIALS,
+            oauth: {
+              scopes: ['scope1'],
+            },
+          },
+          false,
+        );
+
+        expect(transport).toBeInstanceOf(SSEClientTransport);
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const authProvider = (transport as any)._authProvider;
+        expect(authProvider).toBeInstanceOf(GoogleCredentialProvider);
+      });
+
+      it('should throw an error if no URL is provided with GoogleCredentialProvider', async () => {
+        await expect(
+          createTransport(
+            'test-server',
+            {
+              authProviderType: AuthProviderType.GOOGLE_CREDENTIALS,
+              oauth: {
+                scopes: ['scope1'],
+              },
+            },
+            false,
+          ),
+        ).rejects.toThrow(
+          'URL must be provided in the config for Google Credentials provider',
+        );
+      });
+    });
+  });
+  describe('isEnabled', () => {
+    const funcDecl = { name: 'myTool' };
+    const serverName = 'myServer';
+
+    it('should return true if no include or exclude lists are provided', () => {
+      const mcpServerConfig = {};
+      expect(isEnabled(funcDecl, serverName, mcpServerConfig)).toBe(true);
+    });
+
+    it('should return false if the tool is in the exclude list', () => {
+      const mcpServerConfig = { excludeTools: ['myTool'] };
+      expect(isEnabled(funcDecl, serverName, mcpServerConfig)).toBe(false);
+    });
+
+    it('should return true if the tool is in the include list', () => {
+      const mcpServerConfig = { includeTools: ['myTool'] };
+      expect(isEnabled(funcDecl, serverName, mcpServerConfig)).toBe(true);
+    });
+
+    it('should return true if the tool is in the include list with parentheses', () => {
+      const mcpServerConfig = { includeTools: ['myTool()'] };
+      expect(isEnabled(funcDecl, serverName, mcpServerConfig)).toBe(true);
+    });
+
+    it('should return false if the include list exists but does not contain the tool', () => {
+      const mcpServerConfig = { includeTools: ['anotherTool'] };
+      expect(isEnabled(funcDecl, serverName, mcpServerConfig)).toBe(false);
+    });
+
+    it('should return false if the tool is in both the include and exclude lists', () => {
+      const mcpServerConfig = {
+        includeTools: ['myTool'],
+        excludeTools: ['myTool'],
+      };
+      expect(isEnabled(funcDecl, serverName, mcpServerConfig)).toBe(false);
+    });
+
+    it('should return false if the function declaration has no name', () => {
+      const namelessFuncDecl = {};
+      const mcpServerConfig = {};
+      expect(isEnabled(namelessFuncDecl, serverName, mcpServerConfig)).toBe(
+        false,
+      );
+    });
+  });
+
+  describe('hasValidTypes', () => {
+    it('should return true for a valid schema with anyOf', () => {
+      const schema = {
+        anyOf: [{ type: 'string' }, { type: 'number' }],
+      };
+      expect(hasValidTypes(schema)).toBe(true);
+    });
+
+    it('should return false for an invalid schema with anyOf', () => {
+      const schema = {
+        anyOf: [{ type: 'string' }, { description: 'no type' }],
+      };
+      expect(hasValidTypes(schema)).toBe(false);
+    });
+
+    it('should return true for a valid schema with allOf', () => {
+      const schema = {
+        allOf: [
+          { type: 'string' },
+          { type: 'object', properties: { foo: { type: 'string' } } },
+        ],
+      };
+      expect(hasValidTypes(schema)).toBe(true);
+    });
+
+    it('should return false for an invalid schema with allOf', () => {
+      const schema = {
+        allOf: [{ type: 'string' }, { description: 'no type' }],
+      };
+      expect(hasValidTypes(schema)).toBe(false);
+    });
+
+    it('should return true for a valid schema with oneOf', () => {
+      const schema = {
+        oneOf: [{ type: 'string' }, { type: 'number' }],
+      };
+      expect(hasValidTypes(schema)).toBe(true);
+    });
+
+    it('should return false for an invalid schema with oneOf', () => {
+      const schema = {
+        oneOf: [{ type: 'string' }, { description: 'no type' }],
+      };
+      expect(hasValidTypes(schema)).toBe(false);
+    });
+
+    it('should return true for a valid schema with nested subschemas', () => {
+      const schema = {
+        anyOf: [
+          { type: 'string' },
+          {
+            allOf: [
+              { type: 'object', properties: { a: { type: 'string' } } },
+              { type: 'object', properties: { b: { type: 'number' } } },
+            ],
+          },
+        ],
+      };
+      expect(hasValidTypes(schema)).toBe(true);
+    });
+
+    it('should return false for an invalid schema with nested subschemas', () => {
+      const schema = {
+        anyOf: [
+          { type: 'string' },
+          {
+            allOf: [
+              { type: 'object', properties: { a: { type: 'string' } } },
+              { description: 'no type' },
+            ],
+          },
+        ],
+      };
+      expect(hasValidTypes(schema)).toBe(false);
+    });
+
+    it('should return true for a schema with a type and subschemas', () => {
+      const schema = {
+        type: 'string',
+        anyOf: [{ minLength: 1 }, { maxLength: 5 }],
+      };
+      expect(hasValidTypes(schema)).toBe(true);
+    });
+
+    it('should return false for a schema with no type and no subschemas', () => {
+      const schema = {
+        description: 'a schema with no type',
+      };
+      expect(hasValidTypes(schema)).toBe(false);
+    });
+
+    it('should return true for a valid schema', () => {
+      const schema = {
+        type: 'object',
+        properties: {
+          param1: { type: 'string' },
+        },
+      };
+      expect(hasValidTypes(schema)).toBe(true);
+    });
+
+    it('should return false if a parameter is missing a type', () => {
+      const schema = {
+        type: 'object',
+        properties: {
+          param1: { description: 'a param with no type' },
+        },
+      };
+      expect(hasValidTypes(schema)).toBe(false);
+    });
+
+    it('should return false if a nested parameter is missing a type', () => {
+      const schema = {
+        type: 'object',
+        properties: {
+          param1: {
+            type: 'object',
+            properties: {
+              nestedParam: {
+                description: 'a nested param with no type',
+              },
+            },
+          },
+        },
+      };
+      expect(hasValidTypes(schema)).toBe(false);
+    });
+
+    it('should return false if an array item is missing a type', () => {
+      const schema = {
+        type: 'object',
+        properties: {
+          param1: {
+            type: 'array',
+            items: {
+              description: 'an array item with no type',
+            },
+          },
+        },
+      };
+      expect(hasValidTypes(schema)).toBe(false);
+    });
+
+    it('should return true for a schema with no properties', () => {
+      const schema = {
+        type: 'object',
+      };
+      expect(hasValidTypes(schema)).toBe(true);
+    });
+
+    it('should return true for a schema with an empty properties object', () => {
+      const schema = {
+        type: 'object',
+        properties: {},
+      };
+      expect(hasValidTypes(schema)).toBe(true);
+    });
+  });
+});

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

@@ -0,0 +1,1375 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { Transport } from '@modelcontextprotocol/sdk/shared/transport.js';
+import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
+import {
+  SSEClientTransport,
+  SSEClientTransportOptions,
+} from '@modelcontextprotocol/sdk/client/sse.js';
+import {
+  StreamableHTTPClientTransport,
+  StreamableHTTPClientTransportOptions,
+} from '@modelcontextprotocol/sdk/client/streamableHttp.js';
+import {
+  Prompt,
+  ListPromptsResultSchema,
+  GetPromptResult,
+  GetPromptResultSchema,
+  ListRootsRequestSchema,
+} from '@modelcontextprotocol/sdk/types.js';
+import { parse } from 'shell-quote';
+import { AuthProviderType, MCPServerConfig } from '../config/config.js';
+import { GoogleCredentialProvider } from '../mcp/google-auth-provider.js';
+import { DiscoveredMCPTool } from './mcp-tool.js';
+
+import { FunctionDeclaration, mcpToTool } from '@google/genai';
+import { ToolRegistry } from './tool-registry.js';
+import { PromptRegistry } from '../prompts/prompt-registry.js';
+import { MCPOAuthProvider } from '../mcp/oauth-provider.js';
+import { OAuthUtils } from '../mcp/oauth-utils.js';
+import { MCPOAuthTokenStorage } from '../mcp/oauth-token-storage.js';
+import { getErrorMessage } from '../utils/errors.js';
+import { basename } from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { Unsubscribe, WorkspaceContext } from '../utils/workspaceContext.js';
+
+export const MCP_DEFAULT_TIMEOUT_MSEC = 10 * 60 * 1000; // default to 10 minutes
+
+export type DiscoveredMCPPrompt = Prompt & {
+  serverName: string;
+  invoke: (params: Record<string, unknown>) => Promise<GetPromptResult>;
+};
+
+/**
+ * Enum representing the connection status of an MCP server
+ */
+export enum MCPServerStatus {
+  /** Server is disconnected or experiencing errors */
+  DISCONNECTED = 'disconnected',
+  /** Server is in the process of connecting */
+  CONNECTING = 'connecting',
+  /** Server is connected and ready to use */
+  CONNECTED = 'connected',
+}
+
+/**
+ * Enum representing the overall MCP discovery state
+ */
+export enum MCPDiscoveryState {
+  /** Discovery has not started yet */
+  NOT_STARTED = 'not_started',
+  /** Discovery is currently in progress */
+  IN_PROGRESS = 'in_progress',
+  /** Discovery has completed (with or without errors) */
+  COMPLETED = 'completed',
+}
+
+/**
+ * A client for a single MCP server.
+ *
+ * This class is responsible for connecting to, discovering tools from, and
+ * managing the state of a single MCP server.
+ */
+export class McpClient {
+  private client: Client;
+  private transport: Transport | undefined;
+  private status: MCPServerStatus = MCPServerStatus.DISCONNECTED;
+  private isDisconnecting = false;
+
+  constructor(
+    private readonly serverName: string,
+    private readonly serverConfig: MCPServerConfig,
+    private readonly toolRegistry: ToolRegistry,
+    private readonly promptRegistry: PromptRegistry,
+    private readonly workspaceContext: WorkspaceContext,
+    private readonly debugMode: boolean,
+  ) {
+    this.client = new Client({
+      name: `gemini-cli-mcp-client-${this.serverName}`,
+      version: '0.0.1',
+    });
+  }
+
+  /**
+   * Connects to the MCP server.
+   */
+  async connect(): Promise<void> {
+    this.isDisconnecting = false;
+    this.updateStatus(MCPServerStatus.CONNECTING);
+    try {
+      this.transport = await this.createTransport();
+
+      this.client.onerror = (error) => {
+        if (this.isDisconnecting) {
+          return;
+        }
+        console.error(`MCP ERROR (${this.serverName}):`, error.toString());
+        this.updateStatus(MCPServerStatus.DISCONNECTED);
+      };
+
+      this.client.registerCapabilities({
+        roots: {},
+      });
+
+      this.client.setRequestHandler(ListRootsRequestSchema, async () => {
+        const roots = [];
+        for (const dir of this.workspaceContext.getDirectories()) {
+          roots.push({
+            uri: pathToFileURL(dir).toString(),
+            name: basename(dir),
+          });
+        }
+        return {
+          roots,
+        };
+      });
+
+      await this.client.connect(this.transport, {
+        timeout: this.serverConfig.timeout,
+      });
+
+      this.updateStatus(MCPServerStatus.CONNECTED);
+    } catch (error) {
+      this.updateStatus(MCPServerStatus.DISCONNECTED);
+      throw error;
+    }
+  }
+
+  /**
+   * Discovers tools and prompts from the MCP server.
+   */
+  async discover(): Promise<void> {
+    if (this.status !== MCPServerStatus.CONNECTED) {
+      throw new Error('Client is not connected.');
+    }
+
+    const prompts = await this.discoverPrompts();
+    const tools = await this.discoverTools();
+
+    if (prompts.length === 0 && tools.length === 0) {
+      throw new Error('No prompts or tools found on the server.');
+    }
+
+    for (const tool of tools) {
+      this.toolRegistry.registerTool(tool);
+    }
+  }
+
+  /**
+   * Disconnects from the MCP server.
+   */
+  async disconnect(): Promise<void> {
+    this.isDisconnecting = true;
+    if (this.transport) {
+      await this.transport.close();
+    }
+    this.client.close();
+    this.updateStatus(MCPServerStatus.DISCONNECTED);
+  }
+
+  /**
+   * Returns the current status of the client.
+   */
+  getStatus(): MCPServerStatus {
+    return this.status;
+  }
+
+  private updateStatus(status: MCPServerStatus): void {
+    this.status = status;
+    updateMCPServerStatus(this.serverName, status);
+  }
+
+  private async createTransport(): Promise<Transport> {
+    return createTransport(this.serverName, this.serverConfig, this.debugMode);
+  }
+
+  private async discoverTools(): Promise<DiscoveredMCPTool[]> {
+    return discoverTools(this.serverName, this.serverConfig, this.client);
+  }
+
+  private async discoverPrompts(): Promise<Prompt[]> {
+    return discoverPrompts(this.serverName, this.client, this.promptRegistry);
+  }
+}
+
+/**
+ * Map to track the status of each MCP server within the core package
+ */
+const serverStatuses: Map<string, MCPServerStatus> = new Map();
+
+/**
+ * Track the overall MCP discovery state
+ */
+let mcpDiscoveryState: MCPDiscoveryState = MCPDiscoveryState.NOT_STARTED;
+
+/**
+ * Map to track which MCP servers have been discovered to require OAuth
+ */
+export const mcpServerRequiresOAuth: Map<string, boolean> = new Map();
+
+/**
+ * Event listeners for MCP server status changes
+ */
+type StatusChangeListener = (
+  serverName: string,
+  status: MCPServerStatus,
+) => void;
+const statusChangeListeners: StatusChangeListener[] = [];
+
+/**
+ * Add a listener for MCP server status changes
+ */
+export function addMCPStatusChangeListener(
+  listener: StatusChangeListener,
+): void {
+  statusChangeListeners.push(listener);
+}
+
+/**
+ * Remove a listener for MCP server status changes
+ */
+export function removeMCPStatusChangeListener(
+  listener: StatusChangeListener,
+): void {
+  const index = statusChangeListeners.indexOf(listener);
+  if (index !== -1) {
+    statusChangeListeners.splice(index, 1);
+  }
+}
+
+/**
+ * Update the status of an MCP server
+ */
+export function updateMCPServerStatus(
+  serverName: string,
+  status: MCPServerStatus,
+): void {
+  serverStatuses.set(serverName, status);
+  // Notify all listeners
+  for (const listener of statusChangeListeners) {
+    listener(serverName, status);
+  }
+}
+
+/**
+ * Get the current status of an MCP server
+ */
+export function getMCPServerStatus(serverName: string): MCPServerStatus {
+  return serverStatuses.get(serverName) || MCPServerStatus.DISCONNECTED;
+}
+
+/**
+ * Get all MCP server statuses
+ */
+export function getAllMCPServerStatuses(): Map<string, MCPServerStatus> {
+  return new Map(serverStatuses);
+}
+
+/**
+ * Get the current MCP discovery state
+ */
+export function getMCPDiscoveryState(): MCPDiscoveryState {
+  return mcpDiscoveryState;
+}
+
+/**
+ * Extract WWW-Authenticate header from error message string.
+ * This is a more robust approach than regex matching.
+ *
+ * @param errorString The error message string
+ * @returns The www-authenticate header value if found, null otherwise
+ */
+function extractWWWAuthenticateHeader(errorString: string): string | null {
+  // Try multiple patterns to extract the header
+  const patterns = [
+    /www-authenticate:\s*([^\n\r]+)/i,
+    /WWW-Authenticate:\s*([^\n\r]+)/i,
+    /"www-authenticate":\s*"([^"]+)"/i,
+    /'www-authenticate':\s*'([^']+)'/i,
+  ];
+
+  for (const pattern of patterns) {
+    const match = errorString.match(pattern);
+    if (match) {
+      return match[1].trim();
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Handle automatic OAuth discovery and authentication for a server.
+ *
+ * @param mcpServerName The name of the MCP server
+ * @param mcpServerConfig The MCP server configuration
+ * @param wwwAuthenticate The www-authenticate header value
+ * @returns True if OAuth was successfully configured and authenticated, false otherwise
+ */
+async function handleAutomaticOAuth(
+  mcpServerName: string,
+  mcpServerConfig: MCPServerConfig,
+  wwwAuthenticate: string,
+): Promise<boolean> {
+  try {
+    console.log(`🔐 '${mcpServerName}' requires OAuth authentication`);
+
+    // Always try to parse the resource metadata URI from the www-authenticate header
+    let oauthConfig;
+    const resourceMetadataUri =
+      OAuthUtils.parseWWWAuthenticateHeader(wwwAuthenticate);
+    if (resourceMetadataUri) {
+      oauthConfig = await OAuthUtils.discoverOAuthConfig(resourceMetadataUri);
+    } else if (mcpServerConfig.url) {
+      // Fallback: try to discover OAuth config from the base URL for SSE
+      const sseUrl = new URL(mcpServerConfig.url);
+      const baseUrl = `${sseUrl.protocol}//${sseUrl.host}`;
+      oauthConfig = await OAuthUtils.discoverOAuthConfig(baseUrl);
+    } else if (mcpServerConfig.httpUrl) {
+      // Fallback: try to discover OAuth config from the base URL for HTTP
+      const httpUrl = new URL(mcpServerConfig.httpUrl);
+      const baseUrl = `${httpUrl.protocol}//${httpUrl.host}`;
+      oauthConfig = await OAuthUtils.discoverOAuthConfig(baseUrl);
+    }
+
+    if (!oauthConfig) {
+      console.error(
+        `❌ Could not configure OAuth for '${mcpServerName}' - please authenticate manually with /mcp auth ${mcpServerName}`,
+      );
+      return false;
+    }
+
+    // OAuth configuration discovered - proceed with authentication
+
+    // Create OAuth configuration for authentication
+    const oauthAuthConfig = {
+      enabled: true,
+      authorizationUrl: oauthConfig.authorizationUrl,
+      tokenUrl: oauthConfig.tokenUrl,
+      scopes: oauthConfig.scopes || [],
+    };
+
+    // Perform OAuth authentication
+    // Pass the server URL for proper discovery
+    const serverUrl = mcpServerConfig.httpUrl || mcpServerConfig.url;
+    console.log(
+      `Starting OAuth authentication for server '${mcpServerName}'...`,
+    );
+    await MCPOAuthProvider.authenticate(
+      mcpServerName,
+      oauthAuthConfig,
+      serverUrl,
+    );
+
+    console.log(
+      `OAuth authentication successful for server '${mcpServerName}'`,
+    );
+    return true;
+  } catch (error) {
+    console.error(
+      `Failed to handle automatic OAuth for server '${mcpServerName}': ${getErrorMessage(error)}`,
+    );
+    return false;
+  }
+}
+
+/**
+ * Create a transport with OAuth token for the given server configuration.
+ *
+ * @param mcpServerName The name of the MCP server
+ * @param mcpServerConfig The MCP server configuration
+ * @param accessToken The OAuth access token
+ * @returns The transport with OAuth token, or null if creation fails
+ */
+async function createTransportWithOAuth(
+  mcpServerName: string,
+  mcpServerConfig: MCPServerConfig,
+  accessToken: string,
+): Promise<StreamableHTTPClientTransport | SSEClientTransport | null> {
+  try {
+    if (mcpServerConfig.httpUrl) {
+      // Create HTTP transport with OAuth token
+      const oauthTransportOptions: StreamableHTTPClientTransportOptions = {
+        requestInit: {
+          headers: {
+            ...mcpServerConfig.headers,
+            Authorization: `Bearer ${accessToken}`,
+          },
+        },
+      };
+
+      return new StreamableHTTPClientTransport(
+        new URL(mcpServerConfig.httpUrl),
+        oauthTransportOptions,
+      );
+    } else if (mcpServerConfig.url) {
+      // Create SSE transport with OAuth token in Authorization header
+      return new SSEClientTransport(new URL(mcpServerConfig.url), {
+        requestInit: {
+          headers: {
+            ...mcpServerConfig.headers,
+            Authorization: `Bearer ${accessToken}`,
+          },
+        },
+      });
+    }
+
+    return null;
+  } catch (error) {
+    console.error(
+      `Failed to create OAuth transport for server '${mcpServerName}': ${getErrorMessage(error)}`,
+    );
+    return null;
+  }
+}
+
+/**
+ * Discovers tools from all configured MCP servers and registers them with the tool registry.
+ * It orchestrates the connection and discovery process for each server defined in the
+ * configuration, as well as any server specified via a command-line argument.
+ *
+ * @param mcpServers A record of named MCP server configurations.
+ * @param mcpServerCommand An optional command string for a dynamically specified MCP server.
+ * @param toolRegistry The central registry where discovered tools will be registered.
+ * @returns A promise that resolves when the discovery process has been attempted for all servers.
+ */
+export async function discoverMcpTools(
+  mcpServers: Record<string, MCPServerConfig>,
+  mcpServerCommand: string | undefined,
+  toolRegistry: ToolRegistry,
+  promptRegistry: PromptRegistry,
+  debugMode: boolean,
+  workspaceContext: WorkspaceContext,
+): Promise<void> {
+  mcpDiscoveryState = MCPDiscoveryState.IN_PROGRESS;
+  try {
+    mcpServers = populateMcpServerCommand(mcpServers, mcpServerCommand);
+
+    const discoveryPromises = Object.entries(mcpServers).map(
+      ([mcpServerName, mcpServerConfig]) =>
+        connectAndDiscover(
+          mcpServerName,
+          mcpServerConfig,
+          toolRegistry,
+          promptRegistry,
+          debugMode,
+          workspaceContext,
+        ),
+    );
+    await Promise.all(discoveryPromises);
+  } finally {
+    mcpDiscoveryState = MCPDiscoveryState.COMPLETED;
+  }
+}
+
+/** Visible for Testing */
+export function populateMcpServerCommand(
+  mcpServers: Record<string, MCPServerConfig>,
+  mcpServerCommand: string | undefined,
+): Record<string, MCPServerConfig> {
+  if (mcpServerCommand) {
+    const cmd = mcpServerCommand;
+    const args = parse(cmd, process.env) as string[];
+    if (args.some((arg) => typeof arg !== 'string')) {
+      throw new Error('failed to parse mcpServerCommand: ' + cmd);
+    }
+    // use generic server name 'mcp'
+    mcpServers['mcp'] = {
+      command: args[0],
+      args: args.slice(1),
+    };
+  }
+  return mcpServers;
+}
+
+/**
+ * Connects to an MCP server and discovers available tools, registering them with the tool registry.
+ * This function handles the complete lifecycle of connecting to a server, discovering tools,
+ * and cleaning up resources if no tools are found.
+ *
+ * @param mcpServerName The name identifier for this MCP server
+ * @param mcpServerConfig Configuration object containing connection details
+ * @param toolRegistry The registry to register discovered tools with
+ * @returns Promise that resolves when discovery is complete
+ */
+export async function connectAndDiscover(
+  mcpServerName: string,
+  mcpServerConfig: MCPServerConfig,
+  toolRegistry: ToolRegistry,
+  promptRegistry: PromptRegistry,
+  debugMode: boolean,
+  workspaceContext: WorkspaceContext,
+): Promise<void> {
+  updateMCPServerStatus(mcpServerName, MCPServerStatus.CONNECTING);
+
+  let mcpClient: Client | undefined;
+  try {
+    mcpClient = await connectToMcpServer(
+      mcpServerName,
+      mcpServerConfig,
+      debugMode,
+      workspaceContext,
+    );
+
+    mcpClient.onerror = (error) => {
+      console.error(`MCP ERROR (${mcpServerName}):`, error.toString());
+      updateMCPServerStatus(mcpServerName, MCPServerStatus.DISCONNECTED);
+    };
+
+    // Attempt to discover both prompts and tools
+    const prompts = await discoverPrompts(
+      mcpServerName,
+      mcpClient,
+      promptRegistry,
+    );
+    const tools = await discoverTools(
+      mcpServerName,
+      mcpServerConfig,
+      mcpClient,
+    );
+
+    // If we have neither prompts nor tools, it's a failed discovery
+    if (prompts.length === 0 && tools.length === 0) {
+      throw new Error('No prompts or tools found on the server.');
+    }
+
+    // If we found anything, the server is connected
+    updateMCPServerStatus(mcpServerName, MCPServerStatus.CONNECTED);
+
+    // Register any discovered tools
+    for (const tool of tools) {
+      toolRegistry.registerTool(tool);
+    }
+  } catch (error) {
+    if (mcpClient) {
+      mcpClient.close();
+    }
+    console.error(
+      `Error connecting to MCP server '${mcpServerName}': ${getErrorMessage(
+        error,
+      )}`,
+    );
+    updateMCPServerStatus(mcpServerName, MCPServerStatus.DISCONNECTED);
+  }
+}
+
+/**
+ * Recursively validates that a JSON schema and all its nested properties and
+ * items have a `type` defined.
+ *
+ * @param schema The JSON schema to validate.
+ * @returns `true` if the schema is valid, `false` otherwise.
+ *
+ * @visiblefortesting
+ */
+export function hasValidTypes(schema: unknown): boolean {
+  if (typeof schema !== 'object' || schema === null) {
+    // Not a schema object we can validate, or not a schema at all.
+    // Treat as valid as it has no properties to be invalid.
+    return true;
+  }
+
+  const s = schema as Record<string, unknown>;
+
+  if (!s['type']) {
+    // These keywords contain an array of schemas that should be validated.
+    //
+    // If no top level type was given, then they must each have a type.
+    let hasSubSchema = false;
+    const schemaArrayKeywords = ['anyOf', 'allOf', 'oneOf'];
+    for (const keyword of schemaArrayKeywords) {
+      const subSchemas = s[keyword];
+      if (Array.isArray(subSchemas)) {
+        hasSubSchema = true;
+        for (const subSchema of subSchemas) {
+          if (!hasValidTypes(subSchema)) {
+            return false;
+          }
+        }
+      }
+    }
+
+    // If the node itself is missing a type and had no subschemas, then it isn't valid.
+    if (!hasSubSchema) return false;
+  }
+
+  if (s['type'] === 'object' && s['properties']) {
+    if (typeof s['properties'] === 'object' && s['properties'] !== null) {
+      for (const prop of Object.values(s['properties'])) {
+        if (!hasValidTypes(prop)) {
+          return false;
+        }
+      }
+    }
+  }
+
+  if (s['type'] === 'array' && s['items']) {
+    if (!hasValidTypes(s['items'])) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+/**
+ * Discovers and sanitizes tools from a connected MCP client.
+ * It retrieves function declarations from the client, filters out disabled tools,
+ * generates valid names for them, and wraps them in `DiscoveredMCPTool` instances.
+ *
+ * @param mcpServerName The name of the MCP server.
+ * @param mcpServerConfig The configuration for the MCP server.
+ * @param mcpClient The active MCP client instance.
+ * @returns A promise that resolves to an array of discovered and enabled tools.
+ * @throws An error if no enabled tools are found or if the server provides invalid function declarations.
+ */
+export async function discoverTools(
+  mcpServerName: string,
+  mcpServerConfig: MCPServerConfig,
+  mcpClient: Client,
+): Promise<DiscoveredMCPTool[]> {
+  try {
+    const mcpCallableTool = mcpToTool(mcpClient);
+    const tool = await mcpCallableTool.tool();
+
+    if (!Array.isArray(tool.functionDeclarations)) {
+      // This is a valid case for a prompt-only server
+      return [];
+    }
+
+    const discoveredTools: DiscoveredMCPTool[] = [];
+    for (const funcDecl of tool.functionDeclarations) {
+      try {
+        if (!isEnabled(funcDecl, mcpServerName, mcpServerConfig)) {
+          continue;
+        }
+
+        if (!hasValidTypes(funcDecl.parametersJsonSchema)) {
+          console.warn(
+            `Skipping tool '${funcDecl.name}' from MCP server '${mcpServerName}' ` +
+              `because it has missing types in its parameter schema. Please file an ` +
+              `issue with the owner of the MCP server.`,
+          );
+          continue;
+        }
+
+        discoveredTools.push(
+          new DiscoveredMCPTool(
+            mcpCallableTool,
+            mcpServerName,
+            funcDecl.name!,
+            funcDecl.description ?? '',
+            funcDecl.parametersJsonSchema ?? { type: 'object', properties: {} },
+            mcpServerConfig.timeout ?? MCP_DEFAULT_TIMEOUT_MSEC,
+            mcpServerConfig.trust,
+          ),
+        );
+      } catch (error) {
+        console.error(
+          `Error discovering tool: '${
+            funcDecl.name
+          }' from MCP server '${mcpServerName}': ${(error as Error).message}`,
+        );
+      }
+    }
+    return discoveredTools;
+  } catch (error) {
+    if (
+      error instanceof Error &&
+      !error.message?.includes('Method not found')
+    ) {
+      console.error(
+        `Error discovering tools from ${mcpServerName}: ${getErrorMessage(
+          error,
+        )}`,
+      );
+    }
+    return [];
+  }
+}
+
+/**
+ * Discovers and logs prompts from a connected MCP client.
+ * It retrieves prompt declarations from the client and logs their names.
+ *
+ * @param mcpServerName The name of the MCP server.
+ * @param mcpClient The active MCP client instance.
+ */
+export async function discoverPrompts(
+  mcpServerName: string,
+  mcpClient: Client,
+  promptRegistry: PromptRegistry,
+): Promise<Prompt[]> {
+  try {
+    // Only request prompts if the server supports them.
+    if (mcpClient.getServerCapabilities()?.prompts == null) return [];
+
+    const response = await mcpClient.request(
+      { method: 'prompts/list', params: {} },
+      ListPromptsResultSchema,
+    );
+
+    for (const prompt of response.prompts) {
+      promptRegistry.registerPrompt({
+        ...prompt,
+        serverName: mcpServerName,
+        invoke: (params: Record<string, unknown>) =>
+          invokeMcpPrompt(mcpServerName, mcpClient, prompt.name, params),
+      });
+    }
+    return response.prompts;
+  } catch (error) {
+    // It's okay if this fails, not all servers will have prompts.
+    // Don't log an error if the method is not found, which is a common case.
+    if (
+      error instanceof Error &&
+      !error.message?.includes('Method not found')
+    ) {
+      console.error(
+        `Error discovering prompts from ${mcpServerName}: ${getErrorMessage(
+          error,
+        )}`,
+      );
+    }
+    return [];
+  }
+}
+
+/**
+ * Invokes a prompt on a connected MCP client.
+ *
+ * @param mcpServerName The name of the MCP server.
+ * @param mcpClient The active MCP client instance.
+ * @param promptName The name of the prompt to invoke.
+ * @param promptParams The parameters to pass to the prompt.
+ * @returns A promise that resolves to the result of the prompt invocation.
+ */
+export async function invokeMcpPrompt(
+  mcpServerName: string,
+  mcpClient: Client,
+  promptName: string,
+  promptParams: Record<string, unknown>,
+): Promise<GetPromptResult> {
+  try {
+    const response = await mcpClient.request(
+      {
+        method: 'prompts/get',
+        params: {
+          name: promptName,
+          arguments: promptParams,
+        },
+      },
+      GetPromptResultSchema,
+    );
+
+    return response;
+  } catch (error) {
+    if (
+      error instanceof Error &&
+      !error.message?.includes('Method not found')
+    ) {
+      console.error(
+        `Error invoking prompt '${promptName}' from ${mcpServerName} ${promptParams}: ${getErrorMessage(
+          error,
+        )}`,
+      );
+    }
+    throw error;
+  }
+}
+
+/**
+ * Creates and connects an MCP client to a server based on the provided configuration.
+ * It determines the appropriate transport (Stdio, SSE, or Streamable HTTP) and
+ * establishes a connection. It also applies a patch to handle request timeouts.
+ *
+ * @param mcpServerName The name of the MCP server, used for logging and identification.
+ * @param mcpServerConfig The configuration specifying how to connect to the server.
+ * @returns A promise that resolves to a connected MCP `Client` instance.
+ * @throws An error if the connection fails or the configuration is invalid.
+ */
+export async function connectToMcpServer(
+  mcpServerName: string,
+  mcpServerConfig: MCPServerConfig,
+  debugMode: boolean,
+  workspaceContext: WorkspaceContext,
+): Promise<Client> {
+  const mcpClient = new Client({
+    name: 'qwen-code-mcp-client',
+    version: '0.0.1',
+  });
+
+  mcpClient.registerCapabilities({
+    roots: {
+      listChanged: true,
+    },
+  });
+
+  mcpClient.setRequestHandler(ListRootsRequestSchema, async () => {
+    const roots = [];
+    for (const dir of workspaceContext.getDirectories()) {
+      roots.push({
+        uri: pathToFileURL(dir).toString(),
+        name: basename(dir),
+      });
+    }
+    return {
+      roots,
+    };
+  });
+
+  let unlistenDirectories: Unsubscribe | undefined =
+    workspaceContext.onDirectoriesChanged(async () => {
+      try {
+        await mcpClient.notification({
+          method: 'notifications/roots/list_changed',
+        });
+      } catch (_) {
+        // If this fails, its almost certainly because the connection was closed
+        // and we should just stop listening for future directory changes.
+        unlistenDirectories?.();
+        unlistenDirectories = undefined;
+      }
+    });
+
+  // Attempt to pro-actively unsubscribe if the mcp client closes. This API is
+  // very brittle though so we don't have any guarantees, hence the try/catch
+  // above as well.
+  //
+  // Be a good steward and don't just bash over onclose.
+  const oldOnClose = mcpClient.onclose;
+  mcpClient.onclose = () => {
+    oldOnClose?.();
+    unlistenDirectories?.();
+    unlistenDirectories = undefined;
+  };
+
+  // patch Client.callTool to use request timeout as genai McpCallTool.callTool does not do it
+  // TODO: remove this hack once GenAI SDK does callTool with request options
+  if ('callTool' in mcpClient) {
+    const origCallTool = mcpClient.callTool.bind(mcpClient);
+    mcpClient.callTool = function (params, resultSchema, options) {
+      return origCallTool(params, resultSchema, {
+        ...options,
+        timeout: mcpServerConfig.timeout ?? MCP_DEFAULT_TIMEOUT_MSEC,
+      });
+    };
+  }
+
+  try {
+    const transport = await createTransport(
+      mcpServerName,
+      mcpServerConfig,
+      debugMode,
+    );
+    try {
+      await mcpClient.connect(transport, {
+        timeout: mcpServerConfig.timeout ?? MCP_DEFAULT_TIMEOUT_MSEC,
+      });
+      return mcpClient;
+    } catch (error) {
+      await transport.close();
+      throw error;
+    }
+  } catch (error) {
+    // Check if this is a 401 error that might indicate OAuth is required
+    const errorString = String(error);
+    if (
+      errorString.includes('401') &&
+      (mcpServerConfig.httpUrl || mcpServerConfig.url)
+    ) {
+      mcpServerRequiresOAuth.set(mcpServerName, true);
+      // Only trigger automatic OAuth discovery for HTTP servers or when OAuth is explicitly configured
+      // For SSE servers, we should not trigger new OAuth flows automatically
+      const shouldTriggerOAuth =
+        mcpServerConfig.httpUrl || mcpServerConfig.oauth?.enabled;
+
+      if (!shouldTriggerOAuth) {
+        // For SSE servers without explicit OAuth config, if a token was found but rejected, report it accurately.
+        const credentials = await MCPOAuthTokenStorage.getToken(mcpServerName);
+        if (credentials) {
+          const hasStoredTokens = await MCPOAuthProvider.getValidToken(
+            mcpServerName,
+            {
+              // Pass client ID if available
+              clientId: credentials.clientId,
+            },
+          );
+          if (hasStoredTokens) {
+            console.log(
+              `Stored OAuth token for SSE server '${mcpServerName}' was rejected. ` +
+                `Please re-authenticate using: /mcp auth ${mcpServerName}`,
+            );
+          } else {
+            console.log(
+              `401 error received for SSE server '${mcpServerName}' without OAuth configuration. ` +
+                `Please authenticate using: /mcp auth ${mcpServerName}`,
+            );
+          }
+        }
+        throw new Error(
+          `401 error received for SSE server '${mcpServerName}' without OAuth configuration. ` +
+            `Please authenticate using: /mcp auth ${mcpServerName}`,
+        );
+      }
+
+      // Try to extract www-authenticate header from the error
+      let wwwAuthenticate = extractWWWAuthenticateHeader(errorString);
+
+      // If we didn't get the header from the error string, try to get it from the server
+      if (!wwwAuthenticate && mcpServerConfig.url) {
+        console.log(
+          `No www-authenticate header in error, trying to fetch it from server...`,
+        );
+        try {
+          const response = await fetch(mcpServerConfig.url, {
+            method: 'HEAD',
+            headers: {
+              Accept: 'text/event-stream',
+            },
+            signal: AbortSignal.timeout(5000),
+          });
+
+          if (response.status === 401) {
+            wwwAuthenticate = response.headers.get('www-authenticate');
+            if (wwwAuthenticate) {
+              console.log(
+                `Found www-authenticate header from server: ${wwwAuthenticate}`,
+              );
+            }
+          }
+        } catch (fetchError) {
+          console.debug(
+            `Failed to fetch www-authenticate header: ${getErrorMessage(fetchError)}`,
+          );
+        }
+      }
+
+      if (wwwAuthenticate) {
+        console.log(
+          `Received 401 with www-authenticate header: ${wwwAuthenticate}`,
+        );
+
+        // Try automatic OAuth discovery and authentication
+        const oauthSuccess = await handleAutomaticOAuth(
+          mcpServerName,
+          mcpServerConfig,
+          wwwAuthenticate,
+        );
+        if (oauthSuccess) {
+          // Retry connection with OAuth token
+          console.log(
+            `Retrying connection to '${mcpServerName}' with OAuth token...`,
+          );
+
+          // Get the valid token - we need to create a proper OAuth config
+          // The token should already be available from the authentication process
+          const credentials =
+            await MCPOAuthTokenStorage.getToken(mcpServerName);
+          if (credentials) {
+            const accessToken = await MCPOAuthProvider.getValidToken(
+              mcpServerName,
+              {
+                // Pass client ID if available
+                clientId: credentials.clientId,
+              },
+            );
+
+            if (accessToken) {
+              // Create transport with OAuth token
+              const oauthTransport = await createTransportWithOAuth(
+                mcpServerName,
+                mcpServerConfig,
+                accessToken,
+              );
+              if (oauthTransport) {
+                try {
+                  await mcpClient.connect(oauthTransport, {
+                    timeout:
+                      mcpServerConfig.timeout ?? MCP_DEFAULT_TIMEOUT_MSEC,
+                  });
+                  // Connection successful with OAuth
+                  return mcpClient;
+                } catch (retryError) {
+                  console.error(
+                    `Failed to connect with OAuth token: ${getErrorMessage(
+                      retryError,
+                    )}`,
+                  );
+                  throw retryError;
+                }
+              } else {
+                console.error(
+                  `Failed to create OAuth transport for server '${mcpServerName}'`,
+                );
+                throw new Error(
+                  `Failed to create OAuth transport for server '${mcpServerName}'`,
+                );
+              }
+            } else {
+              console.error(
+                `Failed to get OAuth token for server '${mcpServerName}'`,
+              );
+              throw new Error(
+                `Failed to get OAuth token for server '${mcpServerName}'`,
+              );
+            }
+          } else {
+            console.error(
+              `Failed to get credentials for server '${mcpServerName}' after successful OAuth authentication`,
+            );
+            throw new Error(
+              `Failed to get credentials for server '${mcpServerName}' after successful OAuth authentication`,
+            );
+          }
+        } else {
+          console.error(
+            `Failed to handle automatic OAuth for server '${mcpServerName}'`,
+          );
+          throw new Error(
+            `Failed to handle automatic OAuth for server '${mcpServerName}'`,
+          );
+        }
+      } else {
+        // No www-authenticate header found, but we got a 401
+        // Only try OAuth discovery for HTTP servers or when OAuth is explicitly configured
+        // For SSE servers, we should not trigger new OAuth flows automatically
+        const shouldTryDiscovery =
+          mcpServerConfig.httpUrl || mcpServerConfig.oauth?.enabled;
+
+        if (!shouldTryDiscovery) {
+          const credentials =
+            await MCPOAuthTokenStorage.getToken(mcpServerName);
+          if (credentials) {
+            const hasStoredTokens = await MCPOAuthProvider.getValidToken(
+              mcpServerName,
+              {
+                // Pass client ID if available
+                clientId: credentials.clientId,
+              },
+            );
+            if (hasStoredTokens) {
+              console.log(
+                `Stored OAuth token for SSE server '${mcpServerName}' was rejected. ` +
+                  `Please re-authenticate using: /mcp auth ${mcpServerName}`,
+              );
+            } else {
+              console.log(
+                `401 error received for SSE server '${mcpServerName}' without OAuth configuration. ` +
+                  `Please authenticate using: /mcp auth ${mcpServerName}`,
+              );
+            }
+          }
+          throw new Error(
+            `401 error received for SSE server '${mcpServerName}' without OAuth configuration. ` +
+              `Please authenticate using: /mcp auth ${mcpServerName}`,
+          );
+        }
+
+        // For SSE servers, try to discover OAuth configuration from the base URL
+        console.log(`🔍 Attempting OAuth discovery for '${mcpServerName}'...`);
+
+        if (mcpServerConfig.url) {
+          const sseUrl = new URL(mcpServerConfig.url);
+          const baseUrl = `${sseUrl.protocol}//${sseUrl.host}`;
+
+          try {
+            // Try to discover OAuth configuration from the base URL
+            const oauthConfig = await OAuthUtils.discoverOAuthConfig(baseUrl);
+            if (oauthConfig) {
+              console.log(
+                `Discovered OAuth configuration from base URL for server '${mcpServerName}'`,
+              );
+
+              // Create OAuth configuration for authentication
+              const oauthAuthConfig = {
+                enabled: true,
+                authorizationUrl: oauthConfig.authorizationUrl,
+                tokenUrl: oauthConfig.tokenUrl,
+                scopes: oauthConfig.scopes || [],
+              };
+
+              // Perform OAuth authentication
+              // Pass the server URL for proper discovery
+              const serverUrl = mcpServerConfig.httpUrl || mcpServerConfig.url;
+              console.log(
+                `Starting OAuth authentication for server '${mcpServerName}'...`,
+              );
+              await MCPOAuthProvider.authenticate(
+                mcpServerName,
+                oauthAuthConfig,
+                serverUrl,
+              );
+
+              // Retry connection with OAuth token
+              const credentials =
+                await MCPOAuthTokenStorage.getToken(mcpServerName);
+              if (credentials) {
+                const accessToken = await MCPOAuthProvider.getValidToken(
+                  mcpServerName,
+                  {
+                    // Pass client ID if available
+                    clientId: credentials.clientId,
+                  },
+                );
+                if (accessToken) {
+                  // Create transport with OAuth token
+                  const oauthTransport = await createTransportWithOAuth(
+                    mcpServerName,
+                    mcpServerConfig,
+                    accessToken,
+                  );
+                  if (oauthTransport) {
+                    try {
+                      await mcpClient.connect(oauthTransport, {
+                        timeout:
+                          mcpServerConfig.timeout ?? MCP_DEFAULT_TIMEOUT_MSEC,
+                      });
+                      // Connection successful with OAuth
+                      return mcpClient;
+                    } catch (retryError) {
+                      console.error(
+                        `Failed to connect with OAuth token: ${getErrorMessage(
+                          retryError,
+                        )}`,
+                      );
+                      throw retryError;
+                    }
+                  } else {
+                    console.error(
+                      `Failed to create OAuth transport for server '${mcpServerName}'`,
+                    );
+                    throw new Error(
+                      `Failed to create OAuth transport for server '${mcpServerName}'`,
+                    );
+                  }
+                } else {
+                  console.error(
+                    `Failed to get OAuth token for server '${mcpServerName}'`,
+                  );
+                  throw new Error(
+                    `Failed to get OAuth token for server '${mcpServerName}'`,
+                  );
+                }
+              } else {
+                console.error(
+                  `Failed to get stored credentials for server '${mcpServerName}'`,
+                );
+                throw new Error(
+                  `Failed to get stored credentials for server '${mcpServerName}'`,
+                );
+              }
+            } else {
+              console.error(
+                `❌ Could not configure OAuth for '${mcpServerName}' - please authenticate manually with /mcp auth ${mcpServerName}`,
+              );
+              throw new Error(
+                `OAuth configuration failed for '${mcpServerName}'. Please authenticate manually with /mcp auth ${mcpServerName}`,
+              );
+            }
+          } catch (discoveryError) {
+            console.error(
+              `❌ OAuth discovery failed for '${mcpServerName}' - please authenticate manually with /mcp auth ${mcpServerName}`,
+            );
+            throw discoveryError;
+          }
+        } else {
+          console.error(
+            `❌ '${mcpServerName}' requires authentication but no OAuth configuration found`,
+          );
+          throw new Error(
+            `MCP server '${mcpServerName}' requires authentication. Please configure OAuth or check server settings.`,
+          );
+        }
+      }
+    } else {
+      // Handle other connection errors
+      // Create a concise error message
+      const errorMessage = (error as Error).message || String(error);
+      const isNetworkError =
+        errorMessage.includes('ENOTFOUND') ||
+        errorMessage.includes('ECONNREFUSED');
+
+      let conciseError: string;
+      if (isNetworkError) {
+        conciseError = `Cannot connect to '${mcpServerName}' - server may be down or URL incorrect`;
+      } else {
+        conciseError = `Connection failed for '${mcpServerName}': ${errorMessage}`;
+      }
+
+      if (process.env['SANDBOX']) {
+        conciseError += ` (check sandbox availability)`;
+      }
+
+      throw new Error(conciseError);
+    }
+  }
+}
+
+/** Visible for Testing */
+export async function createTransport(
+  mcpServerName: string,
+  mcpServerConfig: MCPServerConfig,
+  debugMode: boolean,
+): Promise<Transport> {
+  if (
+    mcpServerConfig.authProviderType === AuthProviderType.GOOGLE_CREDENTIALS
+  ) {
+    const provider = new GoogleCredentialProvider(mcpServerConfig);
+    const transportOptions:
+      | StreamableHTTPClientTransportOptions
+      | SSEClientTransportOptions = {
+      authProvider: provider,
+    };
+    if (mcpServerConfig.httpUrl) {
+      return new StreamableHTTPClientTransport(
+        new URL(mcpServerConfig.httpUrl),
+        transportOptions,
+      );
+    } else if (mcpServerConfig.url) {
+      return new SSEClientTransport(
+        new URL(mcpServerConfig.url),
+        transportOptions,
+      );
+    }
+    throw new Error('No URL configured for Google Credentials MCP server');
+  }
+
+  // Check if we have OAuth configuration or stored tokens
+  let accessToken: string | null = null;
+  let hasOAuthConfig = mcpServerConfig.oauth?.enabled;
+
+  if (hasOAuthConfig && mcpServerConfig.oauth) {
+    accessToken = await MCPOAuthProvider.getValidToken(
+      mcpServerName,
+      mcpServerConfig.oauth,
+    );
+
+    if (!accessToken) {
+      console.error(
+        `MCP server '${mcpServerName}' requires OAuth authentication. ` +
+          `Please authenticate using the /mcp auth command.`,
+      );
+      throw new Error(
+        `MCP server '${mcpServerName}' requires OAuth authentication. ` +
+          `Please authenticate using the /mcp auth command.`,
+      );
+    }
+  } else {
+    // Check if we have stored OAuth tokens for this server (from previous authentication)
+    const credentials = await MCPOAuthTokenStorage.getToken(mcpServerName);
+    if (credentials) {
+      accessToken = await MCPOAuthProvider.getValidToken(mcpServerName, {
+        // Pass client ID if available
+        clientId: credentials.clientId,
+      });
+
+      if (accessToken) {
+        hasOAuthConfig = true;
+        console.log(`Found stored OAuth token for server '${mcpServerName}'`);
+      }
+    }
+  }
+
+  if (mcpServerConfig.httpUrl) {
+    const transportOptions: StreamableHTTPClientTransportOptions = {};
+
+    // Set up headers with OAuth token if available
+    if (hasOAuthConfig && accessToken) {
+      transportOptions.requestInit = {
+        headers: {
+          ...mcpServerConfig.headers,
+          Authorization: `Bearer ${accessToken}`,
+        },
+      };
+    } else if (mcpServerConfig.headers) {
+      transportOptions.requestInit = {
+        headers: mcpServerConfig.headers,
+      };
+    }
+
+    return new StreamableHTTPClientTransport(
+      new URL(mcpServerConfig.httpUrl),
+      transportOptions,
+    );
+  }
+
+  if (mcpServerConfig.url) {
+    const transportOptions: SSEClientTransportOptions = {};
+
+    // Set up headers with OAuth token if available
+    if (hasOAuthConfig && accessToken) {
+      transportOptions.requestInit = {
+        headers: {
+          ...mcpServerConfig.headers,
+          Authorization: `Bearer ${accessToken}`,
+        },
+      };
+    } else if (mcpServerConfig.headers) {
+      transportOptions.requestInit = {
+        headers: mcpServerConfig.headers,
+      };
+    }
+
+    return new SSEClientTransport(
+      new URL(mcpServerConfig.url),
+      transportOptions,
+    );
+  }
+
+  if (mcpServerConfig.command) {
+    const transport = new StdioClientTransport({
+      command: mcpServerConfig.command,
+      args: mcpServerConfig.args || [],
+      env: {
+        ...process.env,
+        ...(mcpServerConfig.env || {}),
+      } as Record<string, string>,
+      cwd: mcpServerConfig.cwd,
+      stderr: 'pipe',
+    });
+    if (debugMode) {
+      transport.stderr!.on('data', (data) => {
+        const stderrStr = data.toString().trim();
+        console.debug(`[DEBUG] [MCP STDERR (${mcpServerName})]: `, stderrStr);
+      });
+    }
+    return transport;
+  }
+
+  throw new Error(
+    `Invalid configuration: missing httpUrl (for Streamable HTTP), url (for SSE), and command (for stdio).`,
+  );
+}
+
+/** Visible for testing */
+export function isEnabled(
+  funcDecl: FunctionDeclaration,
+  mcpServerName: string,
+  mcpServerConfig: MCPServerConfig,
+): boolean {
+  if (!funcDecl.name) {
+    console.warn(
+      `Discovered a function declaration without a name from MCP server '${mcpServerName}'. Skipping.`,
+    );
+    return false;
+  }
+  const { includeTools, excludeTools } = mcpServerConfig;
+
+  // excludeTools takes precedence over includeTools
+  if (excludeTools && excludeTools.includes(funcDecl.name)) {
+    return false;
+  }
+
+  return (
+    !includeTools ||
+    includeTools.some(
+      (tool) => tool === funcDecl.name || tool.startsWith(`${funcDecl.name}(`),
+    )
+  );
+}

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

@@ -0,0 +1,746 @@
+/**
+ * @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 { DiscoveredMCPTool, generateValidName } from './mcp-tool.js'; // Added getStringifiedResultForDisplay
+import { ToolResult, ToolConfirmationOutcome } from './tools.js'; // Added ToolConfirmationOutcome
+import { CallableTool, Part } from '@google/genai';
+
+// Mock @google/genai mcpToTool and CallableTool
+// We only need to mock the parts of CallableTool that DiscoveredMCPTool uses.
+const mockCallTool = vi.fn();
+const mockToolMethod = vi.fn();
+
+const mockCallableToolInstance: Mocked<CallableTool> = {
+  tool: mockToolMethod as any, // Not directly used by DiscoveredMCPTool instance methods
+  callTool: mockCallTool as any,
+  // Add other methods if DiscoveredMCPTool starts using them
+};
+
+describe('generateValidName', () => {
+  it('should return a valid name for a simple function', () => {
+    expect(generateValidName('myFunction')).toBe('myFunction');
+  });
+
+  it('should replace invalid characters with underscores', () => {
+    expect(generateValidName('invalid-name with spaces')).toBe(
+      'invalid-name_with_spaces',
+    );
+  });
+
+  it('should truncate long names', () => {
+    expect(generateValidName('x'.repeat(80))).toBe(
+      'xxxxxxxxxxxxxxxxxxxxxxxxxxxx___xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx',
+    );
+  });
+
+  it('should handle names with only invalid characters', () => {
+    expect(generateValidName('!@#$%^&*()')).toBe('__________');
+  });
+
+  it('should handle names that are exactly 63 characters long', () => {
+    expect(generateValidName('a'.repeat(63)).length).toBe(63);
+  });
+
+  it('should handle names that are exactly 64 characters long', () => {
+    expect(generateValidName('a'.repeat(64)).length).toBe(63);
+  });
+
+  it('should handle names that are longer than 64 characters', () => {
+    expect(generateValidName('a'.repeat(80)).length).toBe(63);
+  });
+});
+
+describe('DiscoveredMCPTool', () => {
+  const serverName = 'mock-mcp-server';
+  const serverToolName = 'actual-server-tool-name';
+  const baseDescription = 'A test MCP tool.';
+  const inputSchema: Record<string, unknown> = {
+    type: 'object' as const,
+    properties: { param: { type: 'string' } },
+    required: ['param'],
+  };
+
+  let tool: DiscoveredMCPTool;
+
+  beforeEach(() => {
+    mockCallTool.mockClear();
+    mockToolMethod.mockClear();
+    tool = new DiscoveredMCPTool(
+      mockCallableToolInstance,
+      serverName,
+      serverToolName,
+      baseDescription,
+      inputSchema,
+    );
+    // Clear allowlist before each relevant test, especially for shouldConfirmExecute
+    const invocation = tool.build({ param: 'mock' }) as any;
+    invocation.constructor.allowlist.clear();
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  describe('constructor', () => {
+    it('should set properties correctly', () => {
+      expect(tool.name).toBe(serverToolName);
+      expect(tool.schema.name).toBe(serverToolName);
+      expect(tool.schema.description).toBe(baseDescription);
+      expect(tool.schema.parameters).toBeUndefined();
+      expect(tool.schema.parametersJsonSchema).toEqual(inputSchema);
+      expect(tool.serverToolName).toBe(serverToolName);
+      expect(tool.timeout).toBeUndefined();
+    });
+
+    it('should accept and store a custom timeout', () => {
+      const customTimeout = 5000;
+      const toolWithTimeout = new DiscoveredMCPTool(
+        mockCallableToolInstance,
+        serverName,
+        serverToolName,
+        baseDescription,
+        inputSchema,
+        customTimeout,
+      );
+      expect(toolWithTimeout.timeout).toBe(customTimeout);
+    });
+  });
+
+  describe('execute', () => {
+    it('should call mcpTool.callTool with correct parameters and format display output', async () => {
+      const params = { param: 'testValue' };
+      const mockToolSuccessResultObject = {
+        success: true,
+        details: 'executed',
+      };
+      const mockFunctionResponseContent = [
+        {
+          type: 'text',
+          text: JSON.stringify(mockToolSuccessResultObject),
+        },
+      ];
+      const mockMcpToolResponseParts: Part[] = [
+        {
+          functionResponse: {
+            name: serverToolName,
+            response: { content: mockFunctionResponseContent },
+          },
+        },
+      ];
+      mockCallTool.mockResolvedValue(mockMcpToolResponseParts);
+
+      const invocation = tool.build(params);
+      const toolResult: ToolResult = await invocation.execute(
+        new AbortController().signal,
+      );
+
+      expect(mockCallTool).toHaveBeenCalledWith([
+        { name: serverToolName, args: params },
+      ]);
+
+      const stringifiedResponseContent = JSON.stringify(
+        mockToolSuccessResultObject,
+      );
+      expect(toolResult.llmContent).toEqual([
+        { text: stringifiedResponseContent },
+      ]);
+      expect(toolResult.returnDisplay).toBe(stringifiedResponseContent);
+    });
+
+    it('should handle empty result from getStringifiedResultForDisplay', async () => {
+      const params = { param: 'testValue' };
+      const mockMcpToolResponsePartsEmpty: Part[] = [];
+      mockCallTool.mockResolvedValue(mockMcpToolResponsePartsEmpty);
+      const invocation = tool.build(params);
+      const toolResult: ToolResult = await invocation.execute(
+        new AbortController().signal,
+      );
+      expect(toolResult.returnDisplay).toBe('```json\n[]\n```');
+      expect(toolResult.llmContent).toEqual([
+        { text: '[Error: Could not parse tool response]' },
+      ]);
+    });
+
+    it('should propagate rejection if mcpTool.callTool rejects', async () => {
+      const params = { param: 'failCase' };
+      const expectedError = new Error('MCP call failed');
+      mockCallTool.mockRejectedValue(expectedError);
+
+      const invocation = tool.build(params);
+      await expect(
+        invocation.execute(new AbortController().signal),
+      ).rejects.toThrow(expectedError);
+    });
+
+    it.each([
+      { isErrorValue: true, description: 'true (bool)' },
+      { isErrorValue: 'true', description: '"true" (str)' },
+    ])(
+      'should consider a ToolResult with isError $description to be a failure',
+      async ({ isErrorValue }) => {
+        const tool = new DiscoveredMCPTool(
+          mockCallableToolInstance,
+          serverName,
+          serverToolName,
+          baseDescription,
+          inputSchema,
+        );
+        const params = { param: 'isErrorTrueCase' };
+
+        const errorResponse = { isError: isErrorValue };
+        const mockMcpToolResponseParts: Part[] = [
+          {
+            functionResponse: {
+              name: serverToolName,
+              response: { error: errorResponse },
+            },
+          },
+        ];
+        mockCallTool.mockResolvedValue(mockMcpToolResponseParts);
+        const expectedError = new Error(
+          `MCP tool '${serverToolName}' reported tool error with response: ${JSON.stringify(
+            mockMcpToolResponseParts,
+          )}`,
+        );
+
+        const invocation = tool.build(params);
+        await expect(
+          invocation.execute(new AbortController().signal),
+        ).rejects.toThrow(expectedError);
+      },
+    );
+
+    it.each([
+      { isErrorValue: false, description: 'false (bool)' },
+      { isErrorValue: 'false', description: '"false" (str)' },
+    ])(
+      'should consider a ToolResult with isError ${description} to be a success',
+      async ({ isErrorValue }) => {
+        const tool = new DiscoveredMCPTool(
+          mockCallableToolInstance,
+          serverName,
+          serverToolName,
+          baseDescription,
+          inputSchema,
+        );
+        const params = { param: 'isErrorFalseCase' };
+        const mockToolSuccessResultObject = {
+          success: true,
+          details: 'executed',
+        };
+        const mockFunctionResponseContent = [
+          {
+            type: 'text',
+            text: JSON.stringify(mockToolSuccessResultObject),
+          },
+        ];
+
+        const errorResponse = { isError: isErrorValue };
+        const mockMcpToolResponseParts: Part[] = [
+          {
+            functionResponse: {
+              name: serverToolName,
+              response: {
+                error: errorResponse,
+                content: mockFunctionResponseContent,
+              },
+            },
+          },
+        ];
+        mockCallTool.mockResolvedValue(mockMcpToolResponseParts);
+
+        const invocation = tool.build(params);
+        const toolResult = await invocation.execute(
+          new AbortController().signal,
+        );
+
+        const stringifiedResponseContent = JSON.stringify(
+          mockToolSuccessResultObject,
+        );
+        expect(toolResult.llmContent).toEqual([
+          { text: stringifiedResponseContent },
+        ]);
+        expect(toolResult.returnDisplay).toBe(stringifiedResponseContent);
+      },
+    );
+
+    it('should handle a simple text response correctly', async () => {
+      const params = { param: 'test' };
+      const successMessage = 'This is a success message.';
+
+      // Simulate the response from the GenAI SDK, which wraps the MCP
+      // response in a functionResponse Part.
+      const sdkResponse: Part[] = [
+        {
+          functionResponse: {
+            name: serverToolName,
+            response: {
+              // The `content` array contains MCP ContentBlocks.
+              content: [{ type: 'text', text: successMessage }],
+            },
+          },
+        },
+      ];
+      mockCallTool.mockResolvedValue(sdkResponse);
+
+      const invocation = tool.build(params);
+      const toolResult = await invocation.execute(new AbortController().signal);
+
+      // 1. Assert that the llmContent sent to the scheduler is a clean Part array.
+      expect(toolResult.llmContent).toEqual([{ text: successMessage }]);
+
+      // 2. Assert that the display output is the simple text message.
+      expect(toolResult.returnDisplay).toBe(successMessage);
+
+      // 3. Verify that the underlying callTool was made correctly.
+      expect(mockCallTool).toHaveBeenCalledWith([
+        { name: serverToolName, args: params },
+      ]);
+    });
+
+    it('should handle an AudioBlock response', async () => {
+      const params = { param: 'play' };
+      const sdkResponse: Part[] = [
+        {
+          functionResponse: {
+            name: serverToolName,
+            response: {
+              content: [
+                {
+                  type: 'audio',
+                  data: 'BASE64_AUDIO_DATA',
+                  mimeType: 'audio/mp3',
+                },
+              ],
+            },
+          },
+        },
+      ];
+      mockCallTool.mockResolvedValue(sdkResponse);
+
+      const invocation = tool.build(params);
+      const toolResult = await invocation.execute(new AbortController().signal);
+
+      expect(toolResult.llmContent).toEqual([
+        {
+          text: `[Tool '${serverToolName}' provided the following audio data with mime-type: audio/mp3]`,
+        },
+        {
+          inlineData: {
+            mimeType: 'audio/mp3',
+            data: 'BASE64_AUDIO_DATA',
+          },
+        },
+      ]);
+      expect(toolResult.returnDisplay).toBe('[Audio: audio/mp3]');
+    });
+
+    it('should handle a ResourceLinkBlock response', async () => {
+      const params = { param: 'get' };
+      const sdkResponse: Part[] = [
+        {
+          functionResponse: {
+            name: serverToolName,
+            response: {
+              content: [
+                {
+                  type: 'resource_link',
+                  uri: 'file:///path/to/thing',
+                  name: 'resource-name',
+                  title: 'My Resource',
+                },
+              ],
+            },
+          },
+        },
+      ];
+      mockCallTool.mockResolvedValue(sdkResponse);
+
+      const invocation = tool.build(params);
+      const toolResult = await invocation.execute(new AbortController().signal);
+
+      expect(toolResult.llmContent).toEqual([
+        {
+          text: 'Resource Link: My Resource at file:///path/to/thing',
+        },
+      ]);
+      expect(toolResult.returnDisplay).toBe(
+        '[Link to My Resource: file:///path/to/thing]',
+      );
+    });
+
+    it('should handle an embedded text ResourceBlock response', async () => {
+      const params = { param: 'get' };
+      const sdkResponse: Part[] = [
+        {
+          functionResponse: {
+            name: serverToolName,
+            response: {
+              content: [
+                {
+                  type: 'resource',
+                  resource: {
+                    uri: 'file:///path/to/text.txt',
+                    text: 'This is the text content.',
+                    mimeType: 'text/plain',
+                  },
+                },
+              ],
+            },
+          },
+        },
+      ];
+      mockCallTool.mockResolvedValue(sdkResponse);
+
+      const invocation = tool.build(params);
+      const toolResult = await invocation.execute(new AbortController().signal);
+
+      expect(toolResult.llmContent).toEqual([
+        { text: 'This is the text content.' },
+      ]);
+      expect(toolResult.returnDisplay).toBe('This is the text content.');
+    });
+
+    it('should handle an embedded binary ResourceBlock response', async () => {
+      const params = { param: 'get' };
+      const sdkResponse: Part[] = [
+        {
+          functionResponse: {
+            name: serverToolName,
+            response: {
+              content: [
+                {
+                  type: 'resource',
+                  resource: {
+                    uri: 'file:///path/to/data.bin',
+                    blob: 'BASE64_BINARY_DATA',
+                    mimeType: 'application/octet-stream',
+                  },
+                },
+              ],
+            },
+          },
+        },
+      ];
+      mockCallTool.mockResolvedValue(sdkResponse);
+
+      const invocation = tool.build(params);
+      const toolResult = await invocation.execute(new AbortController().signal);
+
+      expect(toolResult.llmContent).toEqual([
+        {
+          text: `[Tool '${serverToolName}' provided the following embedded resource with mime-type: application/octet-stream]`,
+        },
+        {
+          inlineData: {
+            mimeType: 'application/octet-stream',
+            data: 'BASE64_BINARY_DATA',
+          },
+        },
+      ]);
+      expect(toolResult.returnDisplay).toBe(
+        '[Embedded Resource: application/octet-stream]',
+      );
+    });
+
+    it('should handle a mix of content block types', async () => {
+      const params = { param: 'complex' };
+      const sdkResponse: Part[] = [
+        {
+          functionResponse: {
+            name: serverToolName,
+            response: {
+              content: [
+                { type: 'text', text: 'First part.' },
+                {
+                  type: 'image',
+                  data: 'BASE64_IMAGE_DATA',
+                  mimeType: 'image/jpeg',
+                },
+                { type: 'text', text: 'Second part.' },
+              ],
+            },
+          },
+        },
+      ];
+      mockCallTool.mockResolvedValue(sdkResponse);
+
+      const invocation = tool.build(params);
+      const toolResult = await invocation.execute(new AbortController().signal);
+
+      expect(toolResult.llmContent).toEqual([
+        { text: 'First part.' },
+        {
+          text: `[Tool '${serverToolName}' provided the following image data with mime-type: image/jpeg]`,
+        },
+        {
+          inlineData: {
+            mimeType: 'image/jpeg',
+            data: 'BASE64_IMAGE_DATA',
+          },
+        },
+        { text: 'Second part.' },
+      ]);
+      expect(toolResult.returnDisplay).toBe(
+        'First part.\n[Image: image/jpeg]\nSecond part.',
+      );
+    });
+
+    it('should ignore unknown content block types', async () => {
+      const params = { param: 'test' };
+      const sdkResponse: Part[] = [
+        {
+          functionResponse: {
+            name: serverToolName,
+            response: {
+              content: [
+                { type: 'text', text: 'Valid part.' },
+                { type: 'future_block', data: 'some-data' },
+              ],
+            },
+          },
+        },
+      ];
+      mockCallTool.mockResolvedValue(sdkResponse);
+
+      const invocation = tool.build(params);
+      const toolResult = await invocation.execute(new AbortController().signal);
+
+      expect(toolResult.llmContent).toEqual([{ text: 'Valid part.' }]);
+      expect(toolResult.returnDisplay).toBe(
+        'Valid part.\n[Unknown content type: future_block]',
+      );
+    });
+
+    it('should handle a complex mix of content block types', async () => {
+      const params = { param: 'super-complex' };
+      const sdkResponse: Part[] = [
+        {
+          functionResponse: {
+            name: serverToolName,
+            response: {
+              content: [
+                { type: 'text', text: 'Here is a resource.' },
+                {
+                  type: 'resource_link',
+                  uri: 'file:///path/to/resource',
+                  name: 'resource-name',
+                  title: 'My Resource',
+                },
+                {
+                  type: 'resource',
+                  resource: {
+                    uri: 'file:///path/to/text.txt',
+                    text: 'Embedded text content.',
+                    mimeType: 'text/plain',
+                  },
+                },
+                {
+                  type: 'image',
+                  data: 'BASE64_IMAGE_DATA',
+                  mimeType: 'image/jpeg',
+                },
+              ],
+            },
+          },
+        },
+      ];
+      mockCallTool.mockResolvedValue(sdkResponse);
+
+      const invocation = tool.build(params);
+      const toolResult = await invocation.execute(new AbortController().signal);
+
+      expect(toolResult.llmContent).toEqual([
+        { text: 'Here is a resource.' },
+        {
+          text: 'Resource Link: My Resource at file:///path/to/resource',
+        },
+        { text: 'Embedded text content.' },
+        {
+          text: `[Tool '${serverToolName}' provided the following image data with mime-type: image/jpeg]`,
+        },
+        {
+          inlineData: {
+            mimeType: 'image/jpeg',
+            data: 'BASE64_IMAGE_DATA',
+          },
+        },
+      ]);
+      expect(toolResult.returnDisplay).toBe(
+        'Here is a resource.\n[Link to My Resource: file:///path/to/resource]\nEmbedded text content.\n[Image: image/jpeg]',
+      );
+    });
+  });
+
+  describe('shouldConfirmExecute', () => {
+    it('should return false if trust is true', async () => {
+      const trustedTool = new DiscoveredMCPTool(
+        mockCallableToolInstance,
+        serverName,
+        serverToolName,
+        baseDescription,
+        inputSchema,
+        undefined,
+        true,
+      );
+      const invocation = trustedTool.build({ param: 'mock' });
+      expect(
+        await invocation.shouldConfirmExecute(new AbortController().signal),
+      ).toBe(false);
+    });
+
+    it('should return false if server is allowlisted', async () => {
+      const invocation = tool.build({ param: 'mock' }) as any;
+      invocation.constructor.allowlist.add(serverName);
+      expect(
+        await invocation.shouldConfirmExecute(new AbortController().signal),
+      ).toBe(false);
+    });
+
+    it('should return false if tool is allowlisted', async () => {
+      const toolAllowlistKey = `${serverName}.${serverToolName}`;
+      const invocation = tool.build({ param: 'mock' }) as any;
+      invocation.constructor.allowlist.add(toolAllowlistKey);
+      expect(
+        await invocation.shouldConfirmExecute(new AbortController().signal),
+      ).toBe(false);
+    });
+
+    it('should return confirmation details if not trusted and not allowlisted', async () => {
+      const invocation = tool.build({ param: 'mock' });
+      const confirmation = await invocation.shouldConfirmExecute(
+        new AbortController().signal,
+      );
+      expect(confirmation).not.toBe(false);
+      if (confirmation && confirmation.type === 'mcp') {
+        // Type guard for ToolMcpConfirmationDetails
+        expect(confirmation.type).toBe('mcp');
+        expect(confirmation.serverName).toBe(serverName);
+        expect(confirmation.toolName).toBe(serverToolName);
+      } else if (confirmation) {
+        // Handle other possible confirmation types if necessary, or strengthen test if only MCP is expected
+        throw new Error(
+          'Confirmation was not of expected type MCP or was false',
+        );
+      } else {
+        throw new Error(
+          'Confirmation details not in expected format or was false',
+        );
+      }
+    });
+
+    it('should add server to allowlist on ProceedAlwaysServer', async () => {
+      const invocation = tool.build({ param: 'mock' }) as any;
+      const confirmation = await invocation.shouldConfirmExecute(
+        new AbortController().signal,
+      );
+      expect(confirmation).not.toBe(false);
+      if (
+        confirmation &&
+        typeof confirmation === 'object' &&
+        'onConfirm' in confirmation &&
+        typeof confirmation.onConfirm === 'function'
+      ) {
+        await confirmation.onConfirm(
+          ToolConfirmationOutcome.ProceedAlwaysServer,
+        );
+        expect(invocation.constructor.allowlist.has(serverName)).toBe(true);
+      } else {
+        throw new Error(
+          'Confirmation details or onConfirm not in expected format',
+        );
+      }
+    });
+
+    it('should add tool to allowlist on ProceedAlwaysTool', async () => {
+      const toolAllowlistKey = `${serverName}.${serverToolName}`;
+      const invocation = tool.build({ param: 'mock' }) as any;
+      const confirmation = await invocation.shouldConfirmExecute(
+        new AbortController().signal,
+      );
+      expect(confirmation).not.toBe(false);
+      if (
+        confirmation &&
+        typeof confirmation === 'object' &&
+        'onConfirm' in confirmation &&
+        typeof confirmation.onConfirm === 'function'
+      ) {
+        await confirmation.onConfirm(ToolConfirmationOutcome.ProceedAlwaysTool);
+        expect(invocation.constructor.allowlist.has(toolAllowlistKey)).toBe(
+          true,
+        );
+      } else {
+        throw new Error(
+          'Confirmation details or onConfirm not in expected format',
+        );
+      }
+    });
+
+    it('should handle Cancel confirmation outcome', async () => {
+      const invocation = tool.build({ param: 'mock' }) as any;
+      const confirmation = await invocation.shouldConfirmExecute(
+        new AbortController().signal,
+      );
+      expect(confirmation).not.toBe(false);
+      if (
+        confirmation &&
+        typeof confirmation === 'object' &&
+        'onConfirm' in confirmation &&
+        typeof confirmation.onConfirm === 'function'
+      ) {
+        // Cancel should not add anything to allowlist
+        await confirmation.onConfirm(ToolConfirmationOutcome.Cancel);
+        expect(invocation.constructor.allowlist.has(serverName)).toBe(false);
+        expect(
+          invocation.constructor.allowlist.has(
+            `${serverName}.${serverToolName}`,
+          ),
+        ).toBe(false);
+      } else {
+        throw new Error(
+          'Confirmation details or onConfirm not in expected format',
+        );
+      }
+    });
+
+    it('should handle ProceedOnce confirmation outcome', async () => {
+      const invocation = tool.build({ param: 'mock' }) as any;
+      const confirmation = await invocation.shouldConfirmExecute(
+        new AbortController().signal,
+      );
+      expect(confirmation).not.toBe(false);
+      if (
+        confirmation &&
+        typeof confirmation === 'object' &&
+        'onConfirm' in confirmation &&
+        typeof confirmation.onConfirm === 'function'
+      ) {
+        // ProceedOnce should not add anything to allowlist
+        await confirmation.onConfirm(ToolConfirmationOutcome.ProceedOnce);
+        expect(invocation.constructor.allowlist.has(serverName)).toBe(false);
+        expect(
+          invocation.constructor.allowlist.has(
+            `${serverName}.${serverToolName}`,
+          ),
+        ).toBe(false);
+      } else {
+        throw new Error(
+          'Confirmation details or onConfirm not in expected format',
+        );
+      }
+    });
+  });
+});

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

@@ -0,0 +1,356 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import {
+  BaseDeclarativeTool,
+  BaseToolInvocation,
+  Kind,
+  ToolCallConfirmationDetails,
+  ToolConfirmationOutcome,
+  ToolInvocation,
+  ToolMcpConfirmationDetails,
+  ToolResult,
+} from './tools.js';
+import { CallableTool, FunctionCall, Part } from '@google/genai';
+
+type ToolParams = Record<string, unknown>;
+
+// Discriminated union for MCP Content Blocks to ensure type safety.
+type McpTextBlock = {
+  type: 'text';
+  text: string;
+};
+
+type McpMediaBlock = {
+  type: 'image' | 'audio';
+  mimeType: string;
+  data: string;
+};
+
+type McpResourceBlock = {
+  type: 'resource';
+  resource: {
+    text?: string;
+    blob?: string;
+    mimeType?: string;
+  };
+};
+
+type McpResourceLinkBlock = {
+  type: 'resource_link';
+  uri: string;
+  title?: string;
+  name?: string;
+};
+
+type McpContentBlock =
+  | McpTextBlock
+  | McpMediaBlock
+  | McpResourceBlock
+  | McpResourceLinkBlock;
+
+class DiscoveredMCPToolInvocation extends BaseToolInvocation<
+  ToolParams,
+  ToolResult
+> {
+  private static readonly allowlist: Set<string> = new Set();
+
+  constructor(
+    private readonly mcpTool: CallableTool,
+    readonly serverName: string,
+    readonly serverToolName: string,
+    readonly displayName: string,
+    readonly timeout?: number,
+    readonly trust?: boolean,
+    params: ToolParams = {},
+  ) {
+    super(params);
+  }
+
+  override async shouldConfirmExecute(
+    _abortSignal: AbortSignal,
+  ): Promise<ToolCallConfirmationDetails | false> {
+    const serverAllowListKey = this.serverName;
+    const toolAllowListKey = `${this.serverName}.${this.serverToolName}`;
+
+    if (this.trust) {
+      return false; // server is trusted, no confirmation needed
+    }
+
+    if (
+      DiscoveredMCPToolInvocation.allowlist.has(serverAllowListKey) ||
+      DiscoveredMCPToolInvocation.allowlist.has(toolAllowListKey)
+    ) {
+      return false; // server and/or tool already allowlisted
+    }
+
+    const confirmationDetails: ToolMcpConfirmationDetails = {
+      type: 'mcp',
+      title: 'Confirm MCP Tool Execution',
+      serverName: this.serverName,
+      toolName: this.serverToolName, // Display original tool name in confirmation
+      toolDisplayName: this.displayName, // Display global registry name exposed to model and user
+      onConfirm: async (outcome: ToolConfirmationOutcome) => {
+        if (outcome === ToolConfirmationOutcome.ProceedAlwaysServer) {
+          DiscoveredMCPToolInvocation.allowlist.add(serverAllowListKey);
+        } else if (outcome === ToolConfirmationOutcome.ProceedAlwaysTool) {
+          DiscoveredMCPToolInvocation.allowlist.add(toolAllowListKey);
+        }
+      },
+    };
+    return confirmationDetails;
+  }
+
+  // Determine if the response contains tool errors
+  // This is needed because CallToolResults should return errors inside the response.
+  // ref: https://modelcontextprotocol.io/specification/2025-06-18/schema#calltoolresult
+  isMCPToolError(rawResponseParts: Part[]): boolean {
+    const functionResponse = rawResponseParts?.[0]?.functionResponse;
+    const response = functionResponse?.response;
+
+    interface McpError {
+      isError?: boolean | string;
+    }
+
+    if (response) {
+      const error = (response as { error?: McpError })?.error;
+      const isError = error?.isError;
+
+      if (error && (isError === true || isError === 'true')) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  async execute(): Promise<ToolResult> {
+    const functionCalls: FunctionCall[] = [
+      {
+        name: this.serverToolName,
+        args: this.params,
+      },
+    ];
+
+    const rawResponseParts = await this.mcpTool.callTool(functionCalls);
+
+    // Ensure the response is not an error
+    if (this.isMCPToolError(rawResponseParts)) {
+      throw new Error(
+        `MCP tool '${this.serverToolName}' reported tool error with response: ${JSON.stringify(rawResponseParts)}`,
+      );
+    }
+
+    const transformedParts = transformMcpContentToParts(rawResponseParts);
+
+    return {
+      llmContent: transformedParts,
+      returnDisplay: getStringifiedResultForDisplay(rawResponseParts),
+    };
+  }
+
+  getDescription(): string {
+    return this.displayName;
+  }
+}
+
+export class DiscoveredMCPTool extends BaseDeclarativeTool<
+  ToolParams,
+  ToolResult
+> {
+  constructor(
+    private readonly mcpTool: CallableTool,
+    readonly serverName: string,
+    readonly serverToolName: string,
+    description: string,
+    override readonly parameterSchema: unknown,
+    readonly timeout?: number,
+    readonly trust?: boolean,
+    nameOverride?: string,
+  ) {
+    super(
+      nameOverride ?? generateValidName(serverToolName),
+      `${serverToolName} (${serverName} MCP Server)`,
+      description,
+      Kind.Other,
+      parameterSchema,
+      true, // isOutputMarkdown
+      false, // canUpdateOutput
+    );
+  }
+
+  asFullyQualifiedTool(): DiscoveredMCPTool {
+    return new DiscoveredMCPTool(
+      this.mcpTool,
+      this.serverName,
+      this.serverToolName,
+      this.description,
+      this.parameterSchema,
+      this.timeout,
+      this.trust,
+      `${this.serverName}__${this.serverToolName}`,
+    );
+  }
+
+  protected createInvocation(
+    params: ToolParams,
+  ): ToolInvocation<ToolParams, ToolResult> {
+    return new DiscoveredMCPToolInvocation(
+      this.mcpTool,
+      this.serverName,
+      this.serverToolName,
+      this.displayName,
+      this.timeout,
+      this.trust,
+      params,
+    );
+  }
+}
+
+function transformTextBlock(block: McpTextBlock): Part {
+  return { text: block.text };
+}
+
+function transformImageAudioBlock(
+  block: McpMediaBlock,
+  toolName: string,
+): Part[] {
+  return [
+    {
+      text: `[Tool '${toolName}' provided the following ${
+        block.type
+      } data with mime-type: ${block.mimeType}]`,
+    },
+    {
+      inlineData: {
+        mimeType: block.mimeType,
+        data: block.data,
+      },
+    },
+  ];
+}
+
+function transformResourceBlock(
+  block: McpResourceBlock,
+  toolName: string,
+): Part | Part[] | null {
+  const resource = block.resource;
+  if (resource?.text) {
+    return { text: resource.text };
+  }
+  if (resource?.blob) {
+    const mimeType = resource.mimeType || 'application/octet-stream';
+    return [
+      {
+        text: `[Tool '${toolName}' provided the following embedded resource with mime-type: ${mimeType}]`,
+      },
+      {
+        inlineData: {
+          mimeType,
+          data: resource.blob,
+        },
+      },
+    ];
+  }
+  return null;
+}
+
+function transformResourceLinkBlock(block: McpResourceLinkBlock): Part {
+  return {
+    text: `Resource Link: ${block.title || block.name} at ${block.uri}`,
+  };
+}
+
+/**
+ * Transforms the raw MCP content blocks from the SDK response into a
+ * standard GenAI Part array.
+ * @param sdkResponse The raw Part[] array from `mcpTool.callTool()`.
+ * @returns A clean Part[] array ready for the scheduler.
+ */
+function transformMcpContentToParts(sdkResponse: Part[]): Part[] {
+  const funcResponse = sdkResponse?.[0]?.functionResponse;
+  const mcpContent = funcResponse?.response?.['content'] as McpContentBlock[];
+  const toolName = funcResponse?.name || 'unknown tool';
+
+  if (!Array.isArray(mcpContent)) {
+    return [{ text: '[Error: Could not parse tool response]' }];
+  }
+
+  const transformed = mcpContent.flatMap(
+    (block: McpContentBlock): Part | Part[] | null => {
+      switch (block.type) {
+        case 'text':
+          return transformTextBlock(block);
+        case 'image':
+        case 'audio':
+          return transformImageAudioBlock(block, toolName);
+        case 'resource':
+          return transformResourceBlock(block, toolName);
+        case 'resource_link':
+          return transformResourceLinkBlock(block);
+        default:
+          return null;
+      }
+    },
+  );
+
+  return transformed.filter((part): part is Part => part !== null);
+}
+
+/**
+ * Processes the raw response from the MCP tool to generate a clean,
+ * human-readable string for display in the CLI. It summarizes non-text
+ * content and presents text directly.
+ *
+ * @param rawResponse The raw Part[] array from the GenAI SDK.
+ * @returns A formatted string representing the tool's output.
+ */
+function getStringifiedResultForDisplay(rawResponse: Part[]): string {
+  const mcpContent = rawResponse?.[0]?.functionResponse?.response?.[
+    'content'
+  ] as McpContentBlock[];
+
+  if (!Array.isArray(mcpContent)) {
+    return '```json\n' + JSON.stringify(rawResponse, null, 2) + '\n```';
+  }
+
+  const displayParts = mcpContent.map((block: McpContentBlock): string => {
+    switch (block.type) {
+      case 'text':
+        return block.text;
+      case 'image':
+        return `[Image: ${block.mimeType}]`;
+      case 'audio':
+        return `[Audio: ${block.mimeType}]`;
+      case 'resource_link':
+        return `[Link to ${block.title || block.name}: ${block.uri}]`;
+      case 'resource':
+        if (block.resource?.text) {
+          return block.resource.text;
+        }
+        return `[Embedded Resource: ${
+          block.resource?.mimeType || 'unknown type'
+        }]`;
+      default:
+        return `[Unknown content type: ${(block as { type: string }).type}]`;
+    }
+  });
+
+  return displayParts.join('\n');
+}
+
+/** Visible for testing */
+export function generateValidName(name: string) {
+  // Replace invalid characters (based on 400 error message from Gemini API) with underscores
+  let validToolname = name.replace(/[^a-zA-Z0-9_.-]/g, '_');
+
+  // If longer than 63 characters, replace middle with '___'
+  // (Gemini API says max length 64, but actual limit seems to be 63)
+  if (validToolname.length > 63) {
+    validToolname =
+      validToolname.slice(0, 28) + '___' + validToolname.slice(-32);
+  }
+  return validToolname;
+}

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

@@ -0,0 +1,595 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { vi, describe, it, expect, beforeEach, afterEach, Mock } from 'vitest';
+import {
+  MemoryTool,
+  setGeminiMdFilename,
+  getCurrentGeminiMdFilename,
+  getAllGeminiMdFilenames,
+  DEFAULT_CONTEXT_FILENAME,
+} from './memoryTool.js';
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import * as os from 'os';
+import { ToolConfirmationOutcome } from './tools.js';
+
+// Mock dependencies
+vi.mock('fs/promises');
+vi.mock('os');
+
+const MEMORY_SECTION_HEADER = '## Qwen Added Memories';
+
+// Define a type for our fsAdapter to ensure consistency
+interface FsAdapter {
+  readFile: (path: string, encoding: 'utf-8') => Promise<string>;
+  writeFile: (path: string, data: string, encoding: 'utf-8') => Promise<void>;
+  mkdir: (
+    path: string,
+    options: { recursive: boolean },
+  ) => Promise<string | undefined>;
+}
+
+describe('MemoryTool', () => {
+  const mockAbortSignal = new AbortController().signal;
+
+  const mockFsAdapter: {
+    readFile: Mock<FsAdapter['readFile']>;
+    writeFile: Mock<FsAdapter['writeFile']>;
+    mkdir: Mock<FsAdapter['mkdir']>;
+  } = {
+    readFile: vi.fn(),
+    writeFile: vi.fn(),
+    mkdir: vi.fn(),
+  };
+
+  beforeEach(() => {
+    vi.mocked(os.homedir).mockReturnValue(path.join('/mock', 'home'));
+    mockFsAdapter.readFile.mockReset();
+    mockFsAdapter.writeFile.mockReset().mockResolvedValue(undefined);
+    mockFsAdapter.mkdir
+      .mockReset()
+      .mockResolvedValue(undefined as string | undefined);
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+    // Reset GEMINI_MD_FILENAME to its original value after each test
+    setGeminiMdFilename(DEFAULT_CONTEXT_FILENAME);
+  });
+
+  describe('setGeminiMdFilename', () => {
+    it('should update currentGeminiMdFilename when a valid new name is provided', () => {
+      const newName = 'CUSTOM_CONTEXT.md';
+      setGeminiMdFilename(newName);
+      expect(getCurrentGeminiMdFilename()).toBe(newName);
+    });
+
+    it('should not update currentGeminiMdFilename if the new name is empty or whitespace', () => {
+      const initialName = getCurrentGeminiMdFilename(); // Get current before trying to change
+      setGeminiMdFilename('  ');
+      expect(getCurrentGeminiMdFilename()).toBe(initialName);
+
+      setGeminiMdFilename('');
+      expect(getCurrentGeminiMdFilename()).toBe(initialName);
+    });
+
+    it('should handle an array of filenames', () => {
+      const newNames = ['CUSTOM_CONTEXT.md', 'ANOTHER_CONTEXT.md'];
+      setGeminiMdFilename(newNames);
+      expect(getCurrentGeminiMdFilename()).toBe('CUSTOM_CONTEXT.md');
+      expect(getAllGeminiMdFilenames()).toEqual(newNames);
+    });
+  });
+
+  describe('performAddMemoryEntry (static method)', () => {
+    let testFilePath: string;
+
+    beforeEach(() => {
+      testFilePath = path.join(os.homedir(), '.qwen', DEFAULT_CONTEXT_FILENAME);
+    });
+
+    it('should create section and save a fact if file does not exist', async () => {
+      mockFsAdapter.readFile.mockRejectedValue({ code: 'ENOENT' }); // Simulate file not found
+      const fact = 'The sky is blue';
+      await MemoryTool.performAddMemoryEntry(fact, testFilePath, mockFsAdapter);
+
+      expect(mockFsAdapter.mkdir).toHaveBeenCalledWith(
+        path.dirname(testFilePath),
+        {
+          recursive: true,
+        },
+      );
+      expect(mockFsAdapter.writeFile).toHaveBeenCalledOnce();
+      const writeFileCall = mockFsAdapter.writeFile.mock.calls[0];
+      expect(writeFileCall[0]).toBe(testFilePath);
+      const expectedContent = `${MEMORY_SECTION_HEADER}\n- ${fact}\n`;
+      expect(writeFileCall[1]).toBe(expectedContent);
+      expect(writeFileCall[2]).toBe('utf-8');
+    });
+
+    it('should create section and save a fact if file is empty', async () => {
+      mockFsAdapter.readFile.mockResolvedValue(''); // Simulate empty file
+      const fact = 'The sky is blue';
+      await MemoryTool.performAddMemoryEntry(fact, testFilePath, mockFsAdapter);
+      const writeFileCall = mockFsAdapter.writeFile.mock.calls[0];
+      const expectedContent = `${MEMORY_SECTION_HEADER}\n- ${fact}\n`;
+      expect(writeFileCall[1]).toBe(expectedContent);
+    });
+
+    it('should add a fact to an existing section', async () => {
+      const initialContent = `Some preamble.\n\n${MEMORY_SECTION_HEADER}\n- Existing fact 1\n`;
+      mockFsAdapter.readFile.mockResolvedValue(initialContent);
+      const fact = 'New fact 2';
+      await MemoryTool.performAddMemoryEntry(fact, testFilePath, mockFsAdapter);
+
+      expect(mockFsAdapter.writeFile).toHaveBeenCalledOnce();
+      const writeFileCall = mockFsAdapter.writeFile.mock.calls[0];
+      const expectedContent = `Some preamble.\n\n${MEMORY_SECTION_HEADER}\n- Existing fact 1\n- ${fact}\n`;
+      expect(writeFileCall[1]).toBe(expectedContent);
+    });
+
+    it('should add a fact to an existing empty section', async () => {
+      const initialContent = `Some preamble.\n\n${MEMORY_SECTION_HEADER}\n`; // Empty section
+      mockFsAdapter.readFile.mockResolvedValue(initialContent);
+      const fact = 'First fact in section';
+      await MemoryTool.performAddMemoryEntry(fact, testFilePath, mockFsAdapter);
+
+      expect(mockFsAdapter.writeFile).toHaveBeenCalledOnce();
+      const writeFileCall = mockFsAdapter.writeFile.mock.calls[0];
+      const expectedContent = `Some preamble.\n\n${MEMORY_SECTION_HEADER}\n- ${fact}\n`;
+      expect(writeFileCall[1]).toBe(expectedContent);
+    });
+
+    it('should add a fact when other ## sections exist and preserve spacing', async () => {
+      const initialContent = `${MEMORY_SECTION_HEADER}\n- Fact 1\n\n## Another Section\nSome other text.`;
+      mockFsAdapter.readFile.mockResolvedValue(initialContent);
+      const fact = 'Fact 2';
+      await MemoryTool.performAddMemoryEntry(fact, testFilePath, mockFsAdapter);
+
+      expect(mockFsAdapter.writeFile).toHaveBeenCalledOnce();
+      const writeFileCall = mockFsAdapter.writeFile.mock.calls[0];
+      // Note: The implementation ensures a single newline at the end if content exists.
+      const expectedContent = `${MEMORY_SECTION_HEADER}\n- Fact 1\n- ${fact}\n\n## Another Section\nSome other text.\n`;
+      expect(writeFileCall[1]).toBe(expectedContent);
+    });
+
+    it('should correctly trim and add a fact that starts with a dash', async () => {
+      mockFsAdapter.readFile.mockResolvedValue(`${MEMORY_SECTION_HEADER}\n`);
+      const fact = '- - My fact with dashes';
+      await MemoryTool.performAddMemoryEntry(fact, testFilePath, mockFsAdapter);
+      const writeFileCall = mockFsAdapter.writeFile.mock.calls[0];
+      const expectedContent = `${MEMORY_SECTION_HEADER}\n- My fact with dashes\n`;
+      expect(writeFileCall[1]).toBe(expectedContent);
+    });
+
+    it('should handle error from fsAdapter.writeFile', async () => {
+      mockFsAdapter.readFile.mockResolvedValue('');
+      mockFsAdapter.writeFile.mockRejectedValue(new Error('Disk full'));
+      const fact = 'This will fail';
+      await expect(
+        MemoryTool.performAddMemoryEntry(fact, testFilePath, mockFsAdapter),
+      ).rejects.toThrow('[MemoryTool] Failed to add memory entry: Disk full');
+    });
+  });
+
+  describe('execute (instance method)', () => {
+    let memoryTool: MemoryTool;
+    let performAddMemoryEntrySpy: Mock<typeof MemoryTool.performAddMemoryEntry>;
+
+    beforeEach(() => {
+      memoryTool = new MemoryTool();
+      // Spy on the static method for these tests
+      performAddMemoryEntrySpy = vi
+        .spyOn(MemoryTool, 'performAddMemoryEntry')
+        .mockResolvedValue(undefined) as Mock<
+        typeof MemoryTool.performAddMemoryEntry
+      >;
+      // Cast needed as spyOn returns MockInstance
+    });
+
+    it('should have correct name, displayName, description, and schema', () => {
+      expect(memoryTool.name).toBe('save_memory');
+      expect(memoryTool.displayName).toBe('Save Memory');
+      expect(memoryTool.description).toContain(
+        'Saves a specific piece of information',
+      );
+      expect(memoryTool.schema).toBeDefined();
+      expect(memoryTool.schema.name).toBe('save_memory');
+      expect(memoryTool.schema.parametersJsonSchema).toBeDefined();
+    });
+
+    it('should call performAddMemoryEntry with correct parameters and return success for global scope', async () => {
+      const params = { fact: 'The sky is blue', scope: 'global' as const };
+      const invocation = memoryTool.build(params);
+      const result = await invocation.execute(mockAbortSignal);
+
+      // Use getCurrentGeminiMdFilename for the default expectation before any setGeminiMdFilename calls in a test
+      const expectedFilePath = path.join(
+        os.homedir(),
+        '.qwen',
+        getCurrentGeminiMdFilename(), // This will be DEFAULT_CONTEXT_FILENAME unless changed by a test
+      );
+
+      // For this test, we expect the actual fs methods to be passed
+      const expectedFsArgument = {
+        readFile: fs.readFile,
+        writeFile: fs.writeFile,
+        mkdir: fs.mkdir,
+      };
+
+      expect(performAddMemoryEntrySpy).toHaveBeenCalledWith(
+        params.fact,
+        expectedFilePath,
+        expectedFsArgument,
+      );
+      const successMessage = `Okay, I've remembered that in global memory: "${params.fact}"`;
+      expect(result.llmContent).toBe(
+        JSON.stringify({ success: true, message: successMessage }),
+      );
+      expect(result.returnDisplay).toBe(successMessage);
+    });
+
+    it('should call performAddMemoryEntry with correct parameters and return success for project scope', async () => {
+      const params = { fact: 'The sky is blue', scope: 'project' as const };
+      const invocation = memoryTool.build(params);
+      const result = await invocation.execute(mockAbortSignal);
+
+      // For project scope, expect the file to be in current working directory
+      const expectedFilePath = path.join(
+        process.cwd(),
+        getCurrentGeminiMdFilename(),
+      );
+
+      // For this test, we expect the actual fs methods to be passed
+      const expectedFsArgument = {
+        readFile: fs.readFile,
+        writeFile: fs.writeFile,
+        mkdir: fs.mkdir,
+      };
+
+      expect(performAddMemoryEntrySpy).toHaveBeenCalledWith(
+        params.fact,
+        expectedFilePath,
+        expectedFsArgument,
+      );
+      const successMessage = `Okay, I've remembered that in project memory: "${params.fact}"`;
+      expect(result.llmContent).toBe(
+        JSON.stringify({ success: true, message: successMessage }),
+      );
+      expect(result.returnDisplay).toBe(successMessage);
+    });
+
+    it('should return an error if fact is empty', async () => {
+      const params = { fact: ' ' }; // Empty fact
+      expect(memoryTool.validateToolParams(params)).toBe(
+        'Parameter "fact" must be a non-empty string.',
+      );
+      expect(() => memoryTool.build(params)).toThrow(
+        'Parameter "fact" must be a non-empty string.',
+      );
+    });
+
+    it('should handle errors from performAddMemoryEntry', async () => {
+      const params = { fact: 'This will fail', scope: 'global' as const };
+      const underlyingError = new Error(
+        '[MemoryTool] Failed to add memory entry: Disk full',
+      );
+      performAddMemoryEntrySpy.mockRejectedValue(underlyingError);
+
+      const invocation = memoryTool.build(params);
+      const result = await invocation.execute(mockAbortSignal);
+
+      expect(result.llmContent).toBe(
+        JSON.stringify({
+          success: false,
+          error: `Failed to save memory. Detail: ${underlyingError.message}`,
+        }),
+      );
+      expect(result.returnDisplay).toBe(
+        `Error saving memory: ${underlyingError.message}`,
+      );
+    });
+
+    it('should return error when executing without scope parameter', async () => {
+      const params = { fact: 'Test fact' };
+      const invocation = memoryTool.build(params);
+      const result = await invocation.execute(mockAbortSignal);
+
+      expect(result.llmContent).toContain(
+        'Please specify where to save this memory',
+      );
+      expect(result.returnDisplay).toContain('Global:');
+      expect(result.returnDisplay).toContain('Project:');
+    });
+  });
+
+  describe('shouldConfirmExecute', () => {
+    let memoryTool: MemoryTool;
+
+    beforeEach(() => {
+      memoryTool = new MemoryTool();
+      // Mock fs.readFile to return empty string (file doesn't exist)
+      vi.mocked(fs.readFile).mockResolvedValue('');
+
+      // Clear allowlist before each test to ensure clean state
+      const invocation = memoryTool.build({ fact: 'test', scope: 'global' });
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      (invocation.constructor as any).allowlist.clear();
+    });
+
+    it('should return confirmation details when memory file is not allowlisted for global scope', async () => {
+      const params = { fact: 'Test fact', scope: 'global' as const };
+      const invocation = memoryTool.build(params);
+      const result = await invocation.shouldConfirmExecute(mockAbortSignal);
+
+      expect(result).toBeDefined();
+      expect(result).not.toBe(false);
+
+      if (result && result.type === 'edit') {
+        const expectedPath = path.join('~', '.qwen', 'QWEN.md');
+        expect(result.title).toBe(
+          `Confirm Memory Save: ${expectedPath} (global)`,
+        );
+        expect(result.fileName).toContain(path.join('mock', 'home', '.qwen'));
+        expect(result.fileName).toContain('QWEN.md');
+        expect(result.fileDiff).toContain('Index: QWEN.md');
+        expect(result.fileDiff).toContain('+## Qwen Added Memories');
+        expect(result.fileDiff).toContain('+- Test fact');
+        expect(result.originalContent).toBe('');
+        expect(result.newContent).toContain('## Qwen Added Memories');
+        expect(result.newContent).toContain('- Test fact');
+      }
+    });
+
+    it('should return confirmation details when memory file is not allowlisted for project scope', async () => {
+      const params = { fact: 'Test fact', scope: 'project' as const };
+      const invocation = memoryTool.build(params);
+      const result = await invocation.shouldConfirmExecute(mockAbortSignal);
+
+      expect(result).toBeDefined();
+      expect(result).not.toBe(false);
+
+      if (result && result.type === 'edit') {
+        const expectedPath = path.join(process.cwd(), 'QWEN.md');
+        expect(result.title).toBe(
+          `Confirm Memory Save: ${expectedPath} (project)`,
+        );
+        expect(result.fileName).toBe(expectedPath);
+        expect(result.fileDiff).toContain('Index: QWEN.md');
+        expect(result.fileDiff).toContain('+## Qwen Added Memories');
+        expect(result.fileDiff).toContain('+- Test fact');
+        expect(result.originalContent).toBe('');
+        expect(result.newContent).toContain('## Qwen Added Memories');
+        expect(result.newContent).toContain('- Test fact');
+      }
+    });
+
+    it('should return false when memory file is already allowlisted for global scope', async () => {
+      const params = { fact: 'Test fact', scope: 'global' as const };
+      const memoryFilePath = path.join(
+        os.homedir(),
+        '.qwen',
+        getCurrentGeminiMdFilename(),
+      );
+
+      const invocation = memoryTool.build(params);
+      // Add the memory file to the allowlist with the scope-specific key format
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      (invocation.constructor as any).allowlist.add(`${memoryFilePath}_global`);
+
+      const result = await invocation.shouldConfirmExecute(mockAbortSignal);
+
+      expect(result).toBe(false);
+    });
+
+    it('should return false when memory file is already allowlisted for project scope', async () => {
+      const params = { fact: 'Test fact', scope: 'project' as const };
+      const memoryFilePath = path.join(
+        process.cwd(),
+        getCurrentGeminiMdFilename(),
+      );
+
+      const invocation = memoryTool.build(params);
+      // Add the memory file to the allowlist with the scope-specific key format
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      (invocation.constructor as any).allowlist.add(
+        `${memoryFilePath}_project`,
+      );
+
+      const result = await invocation.shouldConfirmExecute(mockAbortSignal);
+
+      expect(result).toBe(false);
+    });
+
+    it('should add memory file to allowlist when ProceedAlways is confirmed for global scope', async () => {
+      const params = { fact: 'Test fact', scope: 'global' as const };
+      const memoryFilePath = path.join(
+        os.homedir(),
+        '.qwen',
+        getCurrentGeminiMdFilename(),
+      );
+
+      const invocation = memoryTool.build(params);
+      const result = await invocation.shouldConfirmExecute(mockAbortSignal);
+
+      expect(result).toBeDefined();
+      expect(result).not.toBe(false);
+
+      if (result && result.type === 'edit') {
+        // Simulate the onConfirm callback
+        await result.onConfirm(ToolConfirmationOutcome.ProceedAlways);
+
+        // Check that the memory file was added to the allowlist with the scope-specific key format
+        expect(
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          (invocation.constructor as any).allowlist.has(
+            `${memoryFilePath}_global`,
+          ),
+        ).toBe(true);
+      }
+    });
+
+    it('should add memory file to allowlist when ProceedAlways is confirmed for project scope', async () => {
+      const params = { fact: 'Test fact', scope: 'project' as const };
+      const memoryFilePath = path.join(
+        process.cwd(),
+        getCurrentGeminiMdFilename(),
+      );
+
+      const invocation = memoryTool.build(params);
+      const result = await invocation.shouldConfirmExecute(mockAbortSignal);
+
+      expect(result).toBeDefined();
+      expect(result).not.toBe(false);
+
+      if (result && result.type === 'edit') {
+        // Simulate the onConfirm callback
+        await result.onConfirm(ToolConfirmationOutcome.ProceedAlways);
+
+        // Check that the memory file was added to the allowlist with the scope-specific key format
+        expect(
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          (invocation.constructor as any).allowlist.has(
+            `${memoryFilePath}_project`,
+          ),
+        ).toBe(true);
+      }
+    });
+
+    it('should not add memory file to allowlist when other outcomes are confirmed', async () => {
+      const params = { fact: 'Test fact', scope: 'global' as const };
+      const memoryFilePath = path.join(
+        os.homedir(),
+        '.qwen',
+        getCurrentGeminiMdFilename(),
+      );
+
+      const invocation = memoryTool.build(params);
+      const result = await invocation.shouldConfirmExecute(mockAbortSignal);
+
+      expect(result).toBeDefined();
+      expect(result).not.toBe(false);
+
+      if (result && result.type === 'edit') {
+        // Simulate the onConfirm callback with different outcomes
+        await result.onConfirm(ToolConfirmationOutcome.ProceedOnce);
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const allowlist = (invocation.constructor as any).allowlist;
+        expect(allowlist.has(`${memoryFilePath}_global`)).toBe(false);
+
+        await result.onConfirm(ToolConfirmationOutcome.Cancel);
+        expect(allowlist.has(`${memoryFilePath}_global`)).toBe(false);
+      }
+    });
+
+    it('should handle existing memory file with content for global scope', async () => {
+      const params = { fact: 'New fact', scope: 'global' as const };
+      const existingContent =
+        'Some existing content.\n\n## Qwen Added Memories\n- Old fact\n';
+
+      // Mock fs.readFile to return existing content
+      vi.mocked(fs.readFile).mockResolvedValue(existingContent);
+
+      const invocation = memoryTool.build(params);
+      const result = await invocation.shouldConfirmExecute(mockAbortSignal);
+
+      expect(result).toBeDefined();
+      expect(result).not.toBe(false);
+
+      if (result && result.type === 'edit') {
+        const expectedPath = path.join('~', '.qwen', 'QWEN.md');
+        expect(result.title).toBe(
+          `Confirm Memory Save: ${expectedPath} (global)`,
+        );
+        expect(result.fileDiff).toContain('Index: QWEN.md');
+        expect(result.fileDiff).toContain('+- New fact');
+        expect(result.originalContent).toBe(existingContent);
+        expect(result.newContent).toContain('- Old fact');
+        expect(result.newContent).toContain('- New fact');
+      }
+    });
+
+    it('should prompt for scope selection when scope is not specified', async () => {
+      const params = { fact: 'Test fact' };
+      const invocation = memoryTool.build(params);
+      const result = await invocation.shouldConfirmExecute(mockAbortSignal);
+
+      expect(result).toBeDefined();
+      expect(result).not.toBe(false);
+
+      if (result && result.type === 'edit') {
+        expect(result.title).toContain('Choose Memory Location');
+        expect(result.title).toContain('GLOBAL');
+        expect(result.title).toContain('PROJECT');
+        expect(result.fileName).toBe('QWEN.md');
+        expect(result.fileDiff).toContain('Test fact');
+        expect(result.fileDiff).toContain('--- QWEN.md');
+        expect(result.fileDiff).toContain('+++ QWEN.md');
+        expect(result.fileDiff).toContain('+- Test fact');
+        expect(result.originalContent).toContain('scope: global');
+        expect(result.originalContent).toContain('INSTRUCTIONS:');
+      }
+    });
+
+    it('should show correct file paths in scope selection prompt', async () => {
+      const params = { fact: 'Test fact' };
+      const invocation = memoryTool.build(params);
+      const result = await invocation.shouldConfirmExecute(mockAbortSignal);
+
+      expect(result).toBeDefined();
+      expect(result).not.toBe(false);
+
+      if (result && result.type === 'edit') {
+        const globalPath = path.join('~', '.qwen', 'QWEN.md');
+        const projectPath = path.join(process.cwd(), 'QWEN.md');
+
+        expect(result.fileDiff).toContain(`Global: ${globalPath}`);
+        expect(result.fileDiff).toContain(`Project: ${projectPath}`);
+        expect(result.fileDiff).toContain('(shared across all projects)');
+        expect(result.fileDiff).toContain('(current project only)');
+      }
+    });
+  });
+
+  describe('getDescription', () => {
+    let memoryTool: MemoryTool;
+
+    beforeEach(() => {
+      memoryTool = new MemoryTool();
+    });
+
+    it('should return correct description for global scope', () => {
+      const params = { fact: 'Test fact', scope: 'global' as const };
+      const invocation = memoryTool.build(params);
+      const description = invocation.getDescription();
+
+      const expectedPath = path.join('~', '.qwen', 'QWEN.md');
+      expect(description).toBe(`${expectedPath} (global)`);
+    });
+
+    it('should return correct description for project scope', () => {
+      const params = { fact: 'Test fact', scope: 'project' as const };
+      const invocation = memoryTool.build(params);
+      const description = invocation.getDescription();
+
+      const expectedPath = path.join(process.cwd(), 'QWEN.md');
+      expect(description).toBe(`${expectedPath} (project)`);
+    });
+
+    it('should show choice prompt when scope is not specified', () => {
+      const params = { fact: 'Test fact' };
+      const invocation = memoryTool.build(params);
+      const description = invocation.getDescription();
+
+      const globalPath = path.join('~', '.qwen', 'QWEN.md');
+      const projectPath = path.join(process.cwd(), 'QWEN.md');
+      expect(description).toBe(
+        `CHOOSE: ${globalPath} (global) OR ${projectPath} (project)`,
+      );
+    });
+  });
+});

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

@@ -0,0 +1,568 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import {
+  BaseDeclarativeTool,
+  BaseToolInvocation,
+  Kind,
+  ToolResult,
+  ToolEditConfirmationDetails,
+  ToolConfirmationOutcome,
+} from './tools.js';
+import { FunctionDeclaration } from '@google/genai';
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { homedir } from 'os';
+import * as Diff from 'diff';
+import { DEFAULT_DIFF_OPTIONS } from './diffOptions.js';
+import { tildeifyPath } from '../utils/paths.js';
+import { ModifiableDeclarativeTool, ModifyContext } from './modifiable-tool.js';
+
+const memoryToolSchemaData: FunctionDeclaration = {
+  name: 'save_memory',
+  description:
+    'Saves a specific piece of information or fact to your long-term memory. Use this when the user explicitly asks you to remember something, or when they state a clear, concise fact that seems important to retain for future interactions.',
+  parametersJsonSchema: {
+    type: 'object',
+    properties: {
+      fact: {
+        type: 'string',
+        description:
+          'The specific fact or piece of information to remember. Should be a clear, self-contained statement.',
+      },
+      scope: {
+        type: 'string',
+        description:
+          'Where to save the memory: "global" saves to user-level ~/.qwen/QWEN.md (shared across all projects), "project" saves to current project\'s QWEN.md (project-specific). If not specified, will prompt user to choose.',
+        enum: ['global', 'project'],
+      },
+    },
+    required: ['fact'],
+  },
+};
+
+const memoryToolDescription = `
+Saves a specific piece of information or fact to your long-term memory.
+
+Use this tool:
+
+- When the user explicitly asks you to remember something (e.g., "Remember that I like pineapple on pizza", "Please save this: my cat's name is Whiskers").
+- When the user states a clear, concise fact about themselves, their preferences, or their environment that seems important for you to retain for future interactions to provide a more personalized and effective assistance.
+
+Do NOT use this tool:
+
+- To remember conversational context that is only relevant for the current session.
+- To save long, complex, or rambling pieces of text. The fact should be relatively short and to the point.
+- If you are unsure whether the information is a fact worth remembering long-term. If in doubt, you can ask the user, "Should I remember that for you?"
+
+## Parameters
+
+- \`fact\` (string, required): The specific fact or piece of information to remember. This should be a clear, self-contained statement. For example, if the user says "My favorite color is blue", the fact would be "My favorite color is blue".
+- \`scope\` (string, optional): Where to save the memory:
+  - "global": Saves to user-level ~/.qwen/QWEN.md (shared across all projects)
+  - "project": Saves to current project's QWEN.md (project-specific)
+  - If not specified, the tool will ask the user where they want to save the memory.
+`;
+
+export const GEMINI_CONFIG_DIR = '.qwen';
+export const DEFAULT_CONTEXT_FILENAME = 'QWEN.md';
+export const MEMORY_SECTION_HEADER = '## Qwen Added Memories';
+
+// This variable will hold the currently configured filename for QWEN.md context files.
+// It defaults to DEFAULT_CONTEXT_FILENAME but can be overridden by setGeminiMdFilename.
+let currentGeminiMdFilename: string | string[] = DEFAULT_CONTEXT_FILENAME;
+
+export function setGeminiMdFilename(newFilename: string | string[]): void {
+  if (Array.isArray(newFilename)) {
+    if (newFilename.length > 0) {
+      currentGeminiMdFilename = newFilename.map((name) => name.trim());
+    }
+  } else if (newFilename && newFilename.trim() !== '') {
+    currentGeminiMdFilename = newFilename.trim();
+  }
+}
+
+export function getCurrentGeminiMdFilename(): string {
+  if (Array.isArray(currentGeminiMdFilename)) {
+    return currentGeminiMdFilename[0];
+  }
+  return currentGeminiMdFilename;
+}
+
+export function getAllGeminiMdFilenames(): string[] {
+  if (Array.isArray(currentGeminiMdFilename)) {
+    return currentGeminiMdFilename;
+  }
+  return [currentGeminiMdFilename];
+}
+
+interface SaveMemoryParams {
+  fact: string;
+  modified_by_user?: boolean;
+  modified_content?: string;
+  scope?: 'global' | 'project';
+}
+
+function getGlobalMemoryFilePath(): string {
+  return path.join(homedir(), GEMINI_CONFIG_DIR, getCurrentGeminiMdFilename());
+}
+
+function getProjectMemoryFilePath(): string {
+  return path.join(process.cwd(), getCurrentGeminiMdFilename());
+}
+
+function getMemoryFilePath(scope: 'global' | 'project' = 'global'): string {
+  return scope === 'project'
+    ? getProjectMemoryFilePath()
+    : getGlobalMemoryFilePath();
+}
+
+/**
+ * Ensures proper newline separation before appending content.
+ */
+function ensureNewlineSeparation(currentContent: string): string {
+  if (currentContent.length === 0) return '';
+  if (currentContent.endsWith('\n\n') || currentContent.endsWith('\r\n\r\n'))
+    return '';
+  if (currentContent.endsWith('\n') || currentContent.endsWith('\r\n'))
+    return '\n';
+  return '\n\n';
+}
+
+/**
+ * Reads the current content of the memory file
+ */
+async function readMemoryFileContent(
+  scope: 'global' | 'project' = 'global',
+): Promise<string> {
+  try {
+    return await fs.readFile(getMemoryFilePath(scope), 'utf-8');
+  } catch (err) {
+    const error = err as Error & { code?: string };
+    if (!(error instanceof Error) || error.code !== 'ENOENT') throw err;
+    return '';
+  }
+}
+
+/**
+ * Computes the new content that would result from adding a memory entry
+ */
+function computeNewContent(currentContent: string, fact: string): string {
+  let processedText = fact.trim();
+  processedText = processedText.replace(/^(-+\s*)+/, '').trim();
+  const newMemoryItem = `- ${processedText}`;
+
+  const headerIndex = currentContent.indexOf(MEMORY_SECTION_HEADER);
+
+  if (headerIndex === -1) {
+    // Header not found, append header and then the entry
+    const separator = ensureNewlineSeparation(currentContent);
+    return (
+      currentContent +
+      `${separator}${MEMORY_SECTION_HEADER}\n${newMemoryItem}\n`
+    );
+  } else {
+    // Header found, find where to insert the new memory entry
+    const startOfSectionContent = headerIndex + MEMORY_SECTION_HEADER.length;
+    let endOfSectionIndex = currentContent.indexOf(
+      '\n## ',
+      startOfSectionContent,
+    );
+    if (endOfSectionIndex === -1) {
+      endOfSectionIndex = currentContent.length; // End of file
+    }
+
+    const beforeSectionMarker = currentContent
+      .substring(0, startOfSectionContent)
+      .trimEnd();
+    let sectionContent = currentContent
+      .substring(startOfSectionContent, endOfSectionIndex)
+      .trimEnd();
+    const afterSectionMarker = currentContent.substring(endOfSectionIndex);
+
+    sectionContent += `\n${newMemoryItem}`;
+    return (
+      `${beforeSectionMarker}\n${sectionContent.trimStart()}\n${afterSectionMarker}`.trimEnd() +
+      '\n'
+    );
+  }
+}
+
+class MemoryToolInvocation extends BaseToolInvocation<
+  SaveMemoryParams,
+  ToolResult
+> {
+  private static readonly allowlist: Set<string> = new Set();
+
+  getDescription(): string {
+    if (!this.params.scope) {
+      const globalPath = tildeifyPath(getMemoryFilePath('global'));
+      const projectPath = tildeifyPath(getMemoryFilePath('project'));
+      return `CHOOSE: ${globalPath} (global) OR ${projectPath} (project)`;
+    }
+    const scope = this.params.scope;
+    const memoryFilePath = getMemoryFilePath(scope);
+    return `${tildeifyPath(memoryFilePath)} (${scope})`;
+  }
+
+  override async shouldConfirmExecute(
+    _abortSignal: AbortSignal,
+  ): Promise<ToolEditConfirmationDetails | false> {
+    // When scope is not specified, show a choice dialog defaulting to global
+    if (!this.params.scope) {
+      // Show preview of what would be added to global by default
+      const defaultScope = 'global';
+      const currentContent = await readMemoryFileContent(defaultScope);
+      const newContent = computeNewContent(currentContent, this.params.fact);
+
+      const globalPath = tildeifyPath(getMemoryFilePath('global'));
+      const projectPath = tildeifyPath(getMemoryFilePath('project'));
+
+      const fileName = path.basename(getMemoryFilePath(defaultScope));
+      const choiceText = `Choose where to save this memory:
+
+"${this.params.fact}"
+
+Options:
+- Global: ${globalPath} (shared across all projects)
+- Project: ${projectPath} (current project only)
+
+Preview of changes to be made to GLOBAL memory:
+`;
+      const fileDiff =
+        choiceText +
+        Diff.createPatch(
+          fileName,
+          currentContent,
+          newContent,
+          'Current',
+          'Proposed (Global)',
+          DEFAULT_DIFF_OPTIONS,
+        );
+
+      const confirmationDetails: ToolEditConfirmationDetails = {
+        type: 'edit',
+        title: `Choose Memory Location: GLOBAL (${globalPath}) or PROJECT (${projectPath})`,
+        fileName,
+        filePath: getMemoryFilePath(defaultScope),
+        fileDiff,
+        originalContent: `scope: global\n\n# INSTRUCTIONS:\n# - Click "Yes" to save to GLOBAL memory: ${globalPath}\n# - Click "Modify with external editor" and change "global" to "project" to save to PROJECT memory: ${projectPath}\n\n${currentContent}`,
+        newContent: `scope: global\n\n# INSTRUCTIONS:\n# - Click "Yes" to save to GLOBAL memory: ${globalPath}\n# - Click "Modify with external editor" and change "global" to "project" to save to PROJECT memory: ${projectPath}\n\n${newContent}`,
+        onConfirm: async (_outcome: ToolConfirmationOutcome) => {
+          // Will be handled in createUpdatedParams
+        },
+      };
+      return confirmationDetails;
+    }
+
+    // Only check allowlist when scope is specified
+    const scope = this.params.scope;
+    const memoryFilePath = getMemoryFilePath(scope);
+    const allowlistKey = `${memoryFilePath}_${scope}`;
+
+    if (MemoryToolInvocation.allowlist.has(allowlistKey)) {
+      return false;
+    }
+
+    // Read current content of the memory file
+    const currentContent = await readMemoryFileContent(scope);
+
+    // Calculate the new content that will be written to the memory file
+    const newContent = computeNewContent(currentContent, this.params.fact);
+
+    const fileName = path.basename(memoryFilePath);
+    const fileDiff = Diff.createPatch(
+      fileName,
+      currentContent,
+      newContent,
+      'Current',
+      'Proposed',
+      DEFAULT_DIFF_OPTIONS,
+    );
+
+    const confirmationDetails: ToolEditConfirmationDetails = {
+      type: 'edit',
+      title: `Confirm Memory Save: ${tildeifyPath(memoryFilePath)} (${scope})`,
+      fileName: memoryFilePath,
+      filePath: memoryFilePath,
+      fileDiff,
+      originalContent: currentContent,
+      newContent,
+      onConfirm: async (outcome: ToolConfirmationOutcome) => {
+        if (outcome === ToolConfirmationOutcome.ProceedAlways) {
+          MemoryToolInvocation.allowlist.add(allowlistKey);
+        }
+      },
+    };
+    return confirmationDetails;
+  }
+
+  async execute(_signal: AbortSignal): Promise<ToolResult> {
+    const { fact, modified_by_user, modified_content } = this.params;
+
+    if (!fact || typeof fact !== 'string' || fact.trim() === '') {
+      const errorMessage = 'Parameter "fact" must be a non-empty string.';
+      return {
+        llmContent: JSON.stringify({ success: false, error: errorMessage }),
+        returnDisplay: `Error: ${errorMessage}`,
+      };
+    }
+
+    // If scope is not specified and user didn't modify content, return error prompting for choice
+    if (!this.params.scope && !modified_by_user) {
+      const globalPath = tildeifyPath(getMemoryFilePath('global'));
+      const projectPath = tildeifyPath(getMemoryFilePath('project'));
+      const errorMessage = `Please specify where to save this memory:
+
+Global: ${globalPath} (shared across all projects)
+Project: ${projectPath} (current project only)`;
+
+      return {
+        llmContent: JSON.stringify({
+          success: false,
+          error: 'Please specify where to save this memory',
+        }),
+        returnDisplay: errorMessage,
+      };
+    }
+
+    const scope = this.params.scope || 'global';
+    const memoryFilePath = getMemoryFilePath(scope);
+
+    try {
+      if (modified_by_user && modified_content !== undefined) {
+        // User modified the content in external editor, write it directly
+        await fs.mkdir(path.dirname(memoryFilePath), {
+          recursive: true,
+        });
+        await fs.writeFile(memoryFilePath, modified_content, 'utf-8');
+        const successMessage = `Okay, I've updated the ${scope} memory file with your modifications.`;
+        return {
+          llmContent: JSON.stringify({
+            success: true,
+            message: successMessage,
+          }),
+          returnDisplay: successMessage,
+        };
+      } else {
+        // Use the normal memory entry logic
+        await MemoryTool.performAddMemoryEntry(fact, memoryFilePath, {
+          readFile: fs.readFile,
+          writeFile: fs.writeFile,
+          mkdir: fs.mkdir,
+        });
+        const successMessage = `Okay, I've remembered that in ${scope} memory: "${fact}"`;
+        return {
+          llmContent: JSON.stringify({
+            success: true,
+            message: successMessage,
+          }),
+          returnDisplay: successMessage,
+        };
+      }
+    } catch (error) {
+      const errorMessage =
+        error instanceof Error ? error.message : String(error);
+      console.error(
+        `[MemoryTool] Error executing save_memory for fact "${fact}" in ${scope}: ${errorMessage}`,
+      );
+      return {
+        llmContent: JSON.stringify({
+          success: false,
+          error: `Failed to save memory. Detail: ${errorMessage}`,
+        }),
+        returnDisplay: `Error saving memory: ${errorMessage}`,
+      };
+    }
+  }
+}
+
+export class MemoryTool
+  extends BaseDeclarativeTool<SaveMemoryParams, ToolResult>
+  implements ModifiableDeclarativeTool<SaveMemoryParams>
+{
+  static readonly Name: string = memoryToolSchemaData.name!;
+  constructor() {
+    super(
+      MemoryTool.Name,
+      'Save Memory',
+      memoryToolDescription,
+      Kind.Think,
+      memoryToolSchemaData.parametersJsonSchema as Record<string, unknown>,
+    );
+  }
+
+  protected override validateToolParamValues(
+    params: SaveMemoryParams,
+  ): string | null {
+    if (params.fact.trim() === '') {
+      return 'Parameter "fact" must be a non-empty string.';
+    }
+
+    return null;
+  }
+
+  protected createInvocation(params: SaveMemoryParams) {
+    return new MemoryToolInvocation(params);
+  }
+
+  static async performAddMemoryEntry(
+    text: string,
+    memoryFilePath: string,
+    fsAdapter: {
+      readFile: (path: string, encoding: 'utf-8') => Promise<string>;
+      writeFile: (
+        path: string,
+        data: string,
+        encoding: 'utf-8',
+      ) => Promise<void>;
+      mkdir: (
+        path: string,
+        options: { recursive: boolean },
+      ) => Promise<string | undefined>;
+    },
+  ): Promise<void> {
+    let processedText = text.trim();
+    // Remove leading hyphens and spaces that might be misinterpreted as markdown list items
+    processedText = processedText.replace(/^(-+\s*)+/, '').trim();
+    const newMemoryItem = `- ${processedText}`;
+
+    try {
+      await fsAdapter.mkdir(path.dirname(memoryFilePath), { recursive: true });
+      let content = '';
+      try {
+        content = await fsAdapter.readFile(memoryFilePath, 'utf-8');
+      } catch (_e) {
+        // File doesn't exist, will be created with header and item.
+      }
+
+      const headerIndex = content.indexOf(MEMORY_SECTION_HEADER);
+
+      if (headerIndex === -1) {
+        // Header not found, append header and then the entry
+        const separator = ensureNewlineSeparation(content);
+        content += `${separator}${MEMORY_SECTION_HEADER}\n${newMemoryItem}\n`;
+      } else {
+        // Header found, find where to insert the new memory entry
+        const startOfSectionContent =
+          headerIndex + MEMORY_SECTION_HEADER.length;
+        let endOfSectionIndex = content.indexOf('\n## ', startOfSectionContent);
+        if (endOfSectionIndex === -1) {
+          endOfSectionIndex = content.length; // End of file
+        }
+
+        const beforeSectionMarker = content
+          .substring(0, startOfSectionContent)
+          .trimEnd();
+        let sectionContent = content
+          .substring(startOfSectionContent, endOfSectionIndex)
+          .trimEnd();
+        const afterSectionMarker = content.substring(endOfSectionIndex);
+
+        sectionContent += `\n${newMemoryItem}`;
+        content =
+          `${beforeSectionMarker}\n${sectionContent.trimStart()}\n${afterSectionMarker}`.trimEnd() +
+          '\n';
+      }
+      await fsAdapter.writeFile(memoryFilePath, content, 'utf-8');
+    } catch (error) {
+      console.error(
+        `[MemoryTool] Error adding memory entry to ${memoryFilePath}:`,
+        error,
+      );
+      throw new Error(
+        `[MemoryTool] Failed to add memory entry: ${error instanceof Error ? error.message : String(error)}`,
+      );
+    }
+  }
+
+  getModifyContext(_abortSignal: AbortSignal): ModifyContext<SaveMemoryParams> {
+    return {
+      getFilePath: (params: SaveMemoryParams) => {
+        // Determine scope from modified content or default
+        let scope = params.scope || 'global';
+        if (params.modified_content) {
+          const scopeMatch = params.modified_content.match(
+            /^scope:\s*(global|project)\s*\n/i,
+          );
+          if (scopeMatch) {
+            scope = scopeMatch[1].toLowerCase() as 'global' | 'project';
+          }
+        }
+        return getMemoryFilePath(scope);
+      },
+      getCurrentContent: async (params: SaveMemoryParams): Promise<string> => {
+        // Check if content starts with scope directive
+        if (params.modified_content) {
+          const scopeMatch = params.modified_content.match(
+            /^scope:\s*(global|project)\s*\n/i,
+          );
+          if (scopeMatch) {
+            const scope = scopeMatch[1].toLowerCase() as 'global' | 'project';
+            const content = await readMemoryFileContent(scope);
+            const globalPath = tildeifyPath(getMemoryFilePath('global'));
+            const projectPath = tildeifyPath(getMemoryFilePath('project'));
+            return `scope: ${scope}\n\n# INSTRUCTIONS:\n# - Save as "global" for GLOBAL memory: ${globalPath}\n# - Save as "project" for PROJECT memory: ${projectPath}\n\n${content}`;
+          }
+        }
+        const scope = params.scope || 'global';
+        const content = await readMemoryFileContent(scope);
+        const globalPath = tildeifyPath(getMemoryFilePath('global'));
+        const projectPath = tildeifyPath(getMemoryFilePath('project'));
+        return `scope: ${scope}\n\n# INSTRUCTIONS:\n# - Save as "global" for GLOBAL memory: ${globalPath}\n# - Save as "project" for PROJECT memory: ${projectPath}\n\n${content}`;
+      },
+      getProposedContent: async (params: SaveMemoryParams): Promise<string> => {
+        let scope = params.scope || 'global';
+
+        // Check if modified content has scope directive
+        if (params.modified_content) {
+          const scopeMatch = params.modified_content.match(
+            /^scope:\s*(global|project)\s*\n/i,
+          );
+          if (scopeMatch) {
+            scope = scopeMatch[1].toLowerCase() as 'global' | 'project';
+          }
+        }
+
+        const currentContent = await readMemoryFileContent(scope);
+        const newContent = computeNewContent(currentContent, params.fact);
+        const globalPath = tildeifyPath(getMemoryFilePath('global'));
+        const projectPath = tildeifyPath(getMemoryFilePath('project'));
+        return `scope: ${scope}\n\n# INSTRUCTIONS:\n# - Save as "global" for GLOBAL memory: ${globalPath}\n# - Save as "project" for PROJECT memory: ${projectPath}\n\n${newContent}`;
+      },
+      createUpdatedParams: (
+        _oldContent: string,
+        modifiedProposedContent: string,
+        originalParams: SaveMemoryParams,
+      ): SaveMemoryParams => {
+        // Parse user's scope choice from modified content
+        const scopeMatch = modifiedProposedContent.match(
+          /^scope:\s*(global|project)/i,
+        );
+        const scope = scopeMatch
+          ? (scopeMatch[1].toLowerCase() as 'global' | 'project')
+          : 'global';
+
+        // Strip out the scope directive and instruction lines, keep only the actual memory content
+        const contentWithoutScope = modifiedProposedContent.replace(
+          /^scope:\s*(global|project)\s*\n/,
+          '',
+        );
+        const actualContent = contentWithoutScope
+          .replace(/^#[^\n]*\n/gm, '')
+          .replace(/^\s*\n/gm, '')
+          .trim();
+
+        return {
+          ...originalParams,
+          scope,
+          modified_by_user: true,
+          modified_content: actualContent,
+        };
+      },
+    };
+  }
+}

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

@@ -0,0 +1,353 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { vi, describe, it, expect, beforeEach, afterEach } from 'vitest';
+import {
+  modifyWithEditor,
+  ModifyContext,
+  ModifiableDeclarativeTool,
+  isModifiableDeclarativeTool,
+} from './modifiable-tool.js';
+import { EditorType } from '../utils/editor.js';
+import fs from 'fs';
+import fsp from 'fs/promises';
+import os from 'os';
+import * as path from 'path';
+
+// Mock dependencies
+const mockOpenDiff = vi.hoisted(() => vi.fn());
+const mockCreatePatch = vi.hoisted(() => vi.fn());
+
+vi.mock('../utils/editor.js', () => ({
+  openDiff: mockOpenDiff,
+}));
+
+vi.mock('diff', () => ({
+  createPatch: mockCreatePatch,
+}));
+
+interface TestParams {
+  filePath: string;
+  someOtherParam: string;
+  modifiedContent?: string;
+}
+
+describe('modifyWithEditor', () => {
+  let testProjectDir: string;
+  let mockModifyContext: ModifyContext<TestParams>;
+  let mockParams: TestParams;
+  let currentContent: string;
+  let proposedContent: string;
+  let modifiedContent: string;
+  let abortSignal: AbortSignal;
+
+  beforeEach(async () => {
+    vi.resetAllMocks();
+
+    testProjectDir = await fsp.mkdtemp(
+      path.join(os.tmpdir(), 'modifiable-tool-test-'),
+    );
+    abortSignal = new AbortController().signal;
+
+    currentContent = 'original content\nline 2\nline 3';
+    proposedContent = 'modified content\nline 2\nline 3';
+    modifiedContent = 'user modified content\nline 2\nline 3\nnew line';
+    mockParams = {
+      filePath: path.join(testProjectDir, 'test.txt'),
+      someOtherParam: 'value',
+    };
+
+    mockModifyContext = {
+      getFilePath: vi.fn().mockReturnValue(mockParams.filePath),
+      getCurrentContent: vi.fn().mockResolvedValue(currentContent),
+      getProposedContent: vi.fn().mockResolvedValue(proposedContent),
+      createUpdatedParams: vi
+        .fn()
+        .mockImplementation((oldContent, modifiedContent, originalParams) => ({
+          ...originalParams,
+          modifiedContent,
+          oldContent,
+        })),
+    };
+
+    mockOpenDiff.mockImplementation(async (_oldPath, newPath) => {
+      await fsp.writeFile(newPath, modifiedContent, 'utf8');
+    });
+
+    mockCreatePatch.mockReturnValue('mock diff content');
+  });
+
+  afterEach(async () => {
+    vi.restoreAllMocks();
+    await fsp.rm(testProjectDir, { recursive: true, force: true });
+    const diffDir = path.join(os.tmpdir(), 'qwen-code-tool-modify-diffs');
+    await fsp.rm(diffDir, { recursive: true, force: true });
+  });
+
+  describe('successful modification', () => {
+    it('should successfully modify content with VSCode editor', async () => {
+      const result = await modifyWithEditor(
+        mockParams,
+        mockModifyContext,
+        'vscode' as EditorType,
+        abortSignal,
+        vi.fn(),
+      );
+
+      expect(mockModifyContext.getCurrentContent).toHaveBeenCalledWith(
+        mockParams,
+      );
+      expect(mockModifyContext.getProposedContent).toHaveBeenCalledWith(
+        mockParams,
+      );
+      expect(mockModifyContext.getFilePath).toHaveBeenCalledWith(mockParams);
+
+      expect(mockOpenDiff).toHaveBeenCalledOnce();
+      const [oldFilePath, newFilePath] = mockOpenDiff.mock.calls[0];
+
+      expect(mockModifyContext.createUpdatedParams).toHaveBeenCalledWith(
+        currentContent,
+        modifiedContent,
+        mockParams,
+      );
+
+      expect(mockCreatePatch).toHaveBeenCalledWith(
+        path.basename(mockParams.filePath),
+        currentContent,
+        modifiedContent,
+        'Current',
+        'Proposed',
+        expect.objectContaining({
+          context: 3,
+          ignoreWhitespace: true,
+        }),
+      );
+
+      // Check that temp files are deleted.
+      await expect(fsp.access(oldFilePath)).rejects.toThrow();
+      await expect(fsp.access(newFilePath)).rejects.toThrow();
+
+      expect(result).toEqual({
+        updatedParams: {
+          ...mockParams,
+          modifiedContent,
+          oldContent: currentContent,
+        },
+        updatedDiff: 'mock diff content',
+      });
+    });
+
+    it('should create temp directory if it does not exist', async () => {
+      const diffDir = path.join(os.tmpdir(), 'qwen-code-tool-modify-diffs');
+      await fsp.rm(diffDir, { recursive: true, force: true }).catch(() => {});
+
+      await modifyWithEditor(
+        mockParams,
+        mockModifyContext,
+        'vscode' as EditorType,
+        abortSignal,
+        vi.fn(),
+      );
+
+      const stats = await fsp.stat(diffDir);
+      expect(stats.isDirectory()).toBe(true);
+    });
+
+    it('should not create temp directory if it already exists', async () => {
+      const diffDir = path.join(os.tmpdir(), 'qwen-code-tool-modify-diffs');
+      await fsp.mkdir(diffDir, { recursive: true });
+
+      const mkdirSpy = vi.spyOn(fs, 'mkdirSync');
+
+      await modifyWithEditor(
+        mockParams,
+        mockModifyContext,
+        'vscode' as EditorType,
+        abortSignal,
+        vi.fn(),
+      );
+
+      expect(mkdirSpy).not.toHaveBeenCalled();
+      mkdirSpy.mockRestore();
+    });
+  });
+
+  it('should handle missing old temp file gracefully', async () => {
+    mockOpenDiff.mockImplementation(async (oldPath, newPath) => {
+      await fsp.writeFile(newPath, modifiedContent, 'utf8');
+      await fsp.unlink(oldPath);
+    });
+
+    const result = await modifyWithEditor(
+      mockParams,
+      mockModifyContext,
+      'vscode' as EditorType,
+      abortSignal,
+      vi.fn(),
+    );
+
+    expect(mockCreatePatch).toHaveBeenCalledWith(
+      path.basename(mockParams.filePath),
+      '',
+      modifiedContent,
+      'Current',
+      'Proposed',
+      expect.objectContaining({
+        context: 3,
+        ignoreWhitespace: true,
+      }),
+    );
+
+    expect(result.updatedParams).toBeDefined();
+    expect(result.updatedDiff).toBe('mock diff content');
+  });
+
+  it('should handle missing new temp file gracefully', async () => {
+    mockOpenDiff.mockImplementation(async (_oldPath, newPath) => {
+      await fsp.unlink(newPath);
+    });
+
+    const result = await modifyWithEditor(
+      mockParams,
+      mockModifyContext,
+      'vscode' as EditorType,
+      abortSignal,
+      vi.fn(),
+    );
+
+    expect(mockCreatePatch).toHaveBeenCalledWith(
+      path.basename(mockParams.filePath),
+      currentContent,
+      '',
+      'Current',
+      'Proposed',
+      expect.objectContaining({
+        context: 3,
+        ignoreWhitespace: true,
+      }),
+    );
+
+    expect(result.updatedParams).toBeDefined();
+    expect(result.updatedDiff).toBe('mock diff content');
+  });
+
+  it('should clean up temp files even if editor fails', async () => {
+    const editorError = new Error('Editor failed to open');
+    mockOpenDiff.mockRejectedValue(editorError);
+
+    const writeSpy = vi.spyOn(fs, 'writeFileSync');
+
+    await expect(
+      modifyWithEditor(
+        mockParams,
+        mockModifyContext,
+        'vscode' as EditorType,
+        abortSignal,
+        vi.fn(),
+      ),
+    ).rejects.toThrow('Editor failed to open');
+
+    expect(writeSpy).toHaveBeenCalledTimes(2);
+    const oldFilePath = writeSpy.mock.calls[0][0] as string;
+    const newFilePath = writeSpy.mock.calls[1][0] as string;
+
+    await expect(fsp.access(oldFilePath)).rejects.toThrow();
+    await expect(fsp.access(newFilePath)).rejects.toThrow();
+
+    writeSpy.mockRestore();
+  });
+
+  it('should handle temp file cleanup errors gracefully', async () => {
+    const consoleErrorSpy = vi
+      .spyOn(console, 'error')
+      .mockImplementation(() => {});
+    vi.spyOn(fs, 'unlinkSync').mockImplementation(() => {
+      throw new Error('Failed to delete file');
+    });
+
+    await modifyWithEditor(
+      mockParams,
+      mockModifyContext,
+      'vscode' as EditorType,
+      abortSignal,
+      vi.fn(),
+    );
+
+    expect(consoleErrorSpy).toHaveBeenCalledTimes(2);
+    expect(consoleErrorSpy).toHaveBeenCalledWith(
+      expect.stringContaining('Error deleting temp diff file:'),
+    );
+
+    consoleErrorSpy.mockRestore();
+  });
+
+  it('should create temp files with correct naming with extension', async () => {
+    const testFilePath = path.join(
+      testProjectDir,
+      'subfolder',
+      'test-file.txt',
+    );
+    mockModifyContext.getFilePath = vi.fn().mockReturnValue(testFilePath);
+
+    await modifyWithEditor(
+      mockParams,
+      mockModifyContext,
+      'vscode' as EditorType,
+      abortSignal,
+      vi.fn(),
+    );
+
+    expect(mockOpenDiff).toHaveBeenCalledOnce();
+    const [oldFilePath, newFilePath] = mockOpenDiff.mock.calls[0];
+    expect(oldFilePath).toMatch(/qwen-code-modify-test-file-old-\d+\.txt$/);
+    expect(newFilePath).toMatch(/qwen-code-modify-test-file-new-\d+\.txt$/);
+
+    const diffDir = path.join(os.tmpdir(), 'qwen-code-tool-modify-diffs');
+    expect(path.dirname(oldFilePath)).toBe(diffDir);
+    expect(path.dirname(newFilePath)).toBe(diffDir);
+  });
+
+  it('should create temp files with correct naming without extension', async () => {
+    const testFilePath = path.join(testProjectDir, 'subfolder', 'test-file');
+    mockModifyContext.getFilePath = vi.fn().mockReturnValue(testFilePath);
+
+    await modifyWithEditor(
+      mockParams,
+      mockModifyContext,
+      'vscode' as EditorType,
+      abortSignal,
+      vi.fn(),
+    );
+
+    expect(mockOpenDiff).toHaveBeenCalledOnce();
+    const [oldFilePath, newFilePath] = mockOpenDiff.mock.calls[0];
+    expect(oldFilePath).toMatch(/qwen-code-modify-test-file-old-\d+$/);
+    expect(newFilePath).toMatch(/qwen-code-modify-test-file-new-\d+$/);
+
+    const diffDir = path.join(os.tmpdir(), 'qwen-code-tool-modify-diffs');
+    expect(path.dirname(oldFilePath)).toBe(diffDir);
+    expect(path.dirname(newFilePath)).toBe(diffDir);
+  });
+});
+
+describe('isModifiableTool', () => {
+  it('should return true for objects with getModifyContext method', () => {
+    const mockTool = {
+      name: 'test-tool',
+      getModifyContext: vi.fn(),
+    } as unknown as ModifiableDeclarativeTool<TestParams>;
+
+    expect(isModifiableDeclarativeTool(mockTool)).toBe(true);
+  });
+
+  it('should return false for objects without getModifyContext method', () => {
+    const mockTool = {
+      name: 'test-tool',
+    } as unknown as ModifiableDeclarativeTool<TestParams>;
+
+    expect(isModifiableDeclarativeTool(mockTool)).toBe(false);
+  });
+});

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

@@ -0,0 +1,170 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { EditorType, openDiff } from '../utils/editor.js';
+import os from 'os';
+import path from 'path';
+import fs from 'fs';
+import * as Diff from 'diff';
+import { DEFAULT_DIFF_OPTIONS } from './diffOptions.js';
+import { isNodeError } from '../utils/errors.js';
+import { AnyDeclarativeTool, DeclarativeTool, ToolResult } from './tools.js';
+
+/**
+ * A declarative tool that supports a modify operation.
+ */
+export interface ModifiableDeclarativeTool<TParams extends object>
+  extends DeclarativeTool<TParams, ToolResult> {
+  getModifyContext(abortSignal: AbortSignal): ModifyContext<TParams>;
+}
+
+export interface ModifyContext<ToolParams> {
+  getFilePath: (params: ToolParams) => string;
+
+  getCurrentContent: (params: ToolParams) => Promise<string>;
+
+  getProposedContent: (params: ToolParams) => Promise<string>;
+
+  createUpdatedParams: (
+    oldContent: string,
+    modifiedProposedContent: string,
+    originalParams: ToolParams,
+  ) => ToolParams;
+}
+
+export interface ModifyResult<ToolParams> {
+  updatedParams: ToolParams;
+  updatedDiff: string;
+}
+
+/**
+ * Type guard to check if a declarative tool is modifiable.
+ */
+export function isModifiableDeclarativeTool(
+  tool: AnyDeclarativeTool,
+): tool is ModifiableDeclarativeTool<object> {
+  return 'getModifyContext' in tool;
+}
+
+function createTempFilesForModify(
+  currentContent: string,
+  proposedContent: string,
+  file_path: string,
+): { oldPath: string; newPath: string } {
+  const tempDir = os.tmpdir();
+  const diffDir = path.join(tempDir, 'qwen-code-tool-modify-diffs');
+
+  if (!fs.existsSync(diffDir)) {
+    fs.mkdirSync(diffDir, { recursive: true });
+  }
+
+  const ext = path.extname(file_path);
+  const fileName = path.basename(file_path, ext);
+  const timestamp = Date.now();
+  const tempOldPath = path.join(
+    diffDir,
+    `qwen-code-modify-${fileName}-old-${timestamp}${ext}`,
+  );
+  const tempNewPath = path.join(
+    diffDir,
+    `qwen-code-modify-${fileName}-new-${timestamp}${ext}`,
+  );
+
+  fs.writeFileSync(tempOldPath, currentContent, 'utf8');
+  fs.writeFileSync(tempNewPath, proposedContent, 'utf8');
+
+  return { oldPath: tempOldPath, newPath: tempNewPath };
+}
+
+function getUpdatedParams<ToolParams>(
+  tmpOldPath: string,
+  tempNewPath: string,
+  originalParams: ToolParams,
+  modifyContext: ModifyContext<ToolParams>,
+): { updatedParams: ToolParams; updatedDiff: string } {
+  let oldContent = '';
+  let newContent = '';
+
+  try {
+    oldContent = fs.readFileSync(tmpOldPath, 'utf8');
+  } catch (err) {
+    if (!isNodeError(err) || err.code !== 'ENOENT') throw err;
+    oldContent = '';
+  }
+
+  try {
+    newContent = fs.readFileSync(tempNewPath, 'utf8');
+  } catch (err) {
+    if (!isNodeError(err) || err.code !== 'ENOENT') throw err;
+    newContent = '';
+  }
+
+  const updatedParams = modifyContext.createUpdatedParams(
+    oldContent,
+    newContent,
+    originalParams,
+  );
+  const updatedDiff = Diff.createPatch(
+    path.basename(modifyContext.getFilePath(originalParams)),
+    oldContent,
+    newContent,
+    'Current',
+    'Proposed',
+    DEFAULT_DIFF_OPTIONS,
+  );
+
+  return { updatedParams, updatedDiff };
+}
+
+function deleteTempFiles(oldPath: string, newPath: string): void {
+  try {
+    fs.unlinkSync(oldPath);
+  } catch {
+    console.error(`Error deleting temp diff file: ${oldPath}`);
+  }
+
+  try {
+    fs.unlinkSync(newPath);
+  } catch {
+    console.error(`Error deleting temp diff file: ${newPath}`);
+  }
+}
+
+/**
+ * Triggers an external editor for the user to modify the proposed content,
+ * and returns the updated tool parameters and the diff after the user has modified the proposed content.
+ */
+export async function modifyWithEditor<ToolParams>(
+  originalParams: ToolParams,
+  modifyContext: ModifyContext<ToolParams>,
+  editorType: EditorType,
+  _abortSignal: AbortSignal,
+  onEditorClose: () => void,
+): Promise<ModifyResult<ToolParams>> {
+  const currentContent = await modifyContext.getCurrentContent(originalParams);
+  const proposedContent =
+    await modifyContext.getProposedContent(originalParams);
+
+  const { oldPath, newPath } = createTempFilesForModify(
+    currentContent,
+    proposedContent,
+    modifyContext.getFilePath(originalParams),
+  );
+
+  try {
+    await openDiff(oldPath, newPath, editorType, onEditorClose);
+    const result = getUpdatedParams(
+      oldPath,
+      newPath,
+      originalParams,
+      modifyContext,
+    );
+
+    return result;
+  } finally {
+    deleteTempFiles(oldPath, newPath);
+  }
+}

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

@@ -0,0 +1,448 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { ReadFileTool, ReadFileToolParams } from './read-file.js';
+import { ToolErrorType } from './tool-error.js';
+import path from 'path';
+import os from 'os';
+import fs from 'fs';
+import fsp from 'fs/promises';
+import { Config } from '../config/config.js';
+import { FileDiscoveryService } from '../services/fileDiscoveryService.js';
+import { StandardFileSystemService } from '../services/fileSystemService.js';
+import { createMockWorkspaceContext } from '../test-utils/mockWorkspaceContext.js';
+import { ToolInvocation, ToolResult } from './tools.js';
+
+describe('ReadFileTool', () => {
+  let tempRootDir: string;
+  let tool: ReadFileTool;
+  const abortSignal = new AbortController().signal;
+
+  beforeEach(async () => {
+    // Create a unique temporary root directory for each test run
+    tempRootDir = await fsp.mkdtemp(
+      path.join(os.tmpdir(), 'read-file-tool-root-'),
+    );
+
+    const mockConfigInstance = {
+      getFileService: () => new FileDiscoveryService(tempRootDir),
+      getFileSystemService: () => new StandardFileSystemService(),
+      getTargetDir: () => tempRootDir,
+      getWorkspaceContext: () => createMockWorkspaceContext(tempRootDir),
+    } as unknown as Config;
+    tool = new ReadFileTool(mockConfigInstance);
+  });
+
+  afterEach(async () => {
+    // Clean up the temporary root directory
+    if (fs.existsSync(tempRootDir)) {
+      await fsp.rm(tempRootDir, { recursive: true, force: true });
+    }
+  });
+
+  describe('build', () => {
+    it('should return an invocation for valid params (absolute path within root)', () => {
+      const params: ReadFileToolParams = {
+        absolute_path: path.join(tempRootDir, 'test.txt'),
+      };
+      const result = tool.build(params);
+      expect(typeof result).not.toBe('string');
+    });
+
+    it('should throw error if file path is relative', () => {
+      const params: ReadFileToolParams = {
+        absolute_path: 'relative/path.txt',
+      };
+      expect(() => tool.build(params)).toThrow(
+        'File path must be absolute, but was relative: relative/path.txt. You must provide an absolute path.',
+      );
+    });
+
+    it('should throw error if path is outside root', () => {
+      const params: ReadFileToolParams = {
+        absolute_path: '/outside/root.txt',
+      };
+      expect(() => tool.build(params)).toThrow(
+        /File path must be within one of the workspace directories/,
+      );
+    });
+
+    it('should throw error if path is empty', () => {
+      const params: ReadFileToolParams = {
+        absolute_path: '',
+      };
+      expect(() => tool.build(params)).toThrow(
+        /The 'absolute_path' parameter must be non-empty./,
+      );
+    });
+
+    it('should throw error if offset is negative', () => {
+      const params: ReadFileToolParams = {
+        absolute_path: path.join(tempRootDir, 'test.txt'),
+        offset: -1,
+      };
+      expect(() => tool.build(params)).toThrow(
+        'Offset must be a non-negative number',
+      );
+    });
+
+    it('should throw error if limit is zero or negative', () => {
+      const params: ReadFileToolParams = {
+        absolute_path: path.join(tempRootDir, 'test.txt'),
+        limit: 0,
+      };
+      expect(() => tool.build(params)).toThrow(
+        'Limit must be a positive number',
+      );
+    });
+  });
+
+  describe('getDescription', () => {
+    it('should return relative path without limit/offset', () => {
+      const subDir = path.join(tempRootDir, 'sub', 'dir');
+      const params: ReadFileToolParams = {
+        absolute_path: path.join(subDir, 'file.txt'),
+      };
+      const invocation = tool.build(params);
+      expect(typeof invocation).not.toBe('string');
+      expect(
+        (
+          invocation as ToolInvocation<ReadFileToolParams, ToolResult>
+        ).getDescription(),
+      ).toBe(path.join('sub', 'dir', 'file.txt'));
+    });
+
+    it('should return shortened path when file path is deep', () => {
+      const deepPath = path.join(
+        tempRootDir,
+        'very',
+        'deep',
+        'directory',
+        'structure',
+        'that',
+        'exceeds',
+        'the',
+        'normal',
+        'limit',
+        'file.txt',
+      );
+      const params: ReadFileToolParams = { absolute_path: deepPath };
+      const invocation = tool.build(params);
+      expect(typeof invocation).not.toBe('string');
+      const desc = (
+        invocation as ToolInvocation<ReadFileToolParams, ToolResult>
+      ).getDescription();
+      expect(desc).toContain('...');
+      expect(desc).toContain('file.txt');
+    });
+
+    it('should handle non-normalized file paths correctly', () => {
+      const subDir = path.join(tempRootDir, 'sub', 'dir');
+      const params: ReadFileToolParams = {
+        absolute_path: path.join(subDir, '..', 'dir', 'file.txt'),
+      };
+      const invocation = tool.build(params);
+      expect(typeof invocation).not.toBe('string');
+      expect(
+        (
+          invocation as ToolInvocation<ReadFileToolParams, ToolResult>
+        ).getDescription(),
+      ).toBe(path.join('sub', 'dir', 'file.txt'));
+    });
+
+    it('should return . if path is the root directory', () => {
+      const params: ReadFileToolParams = { absolute_path: tempRootDir };
+      const invocation = tool.build(params);
+      expect(typeof invocation).not.toBe('string');
+      expect(
+        (
+          invocation as ToolInvocation<ReadFileToolParams, ToolResult>
+        ).getDescription(),
+      ).toBe('.');
+    });
+  });
+
+  describe('execute', () => {
+    it('should return error if file does not exist', async () => {
+      const filePath = path.join(tempRootDir, 'nonexistent.txt');
+      const params: ReadFileToolParams = { absolute_path: filePath };
+      const invocation = tool.build(params) as ToolInvocation<
+        ReadFileToolParams,
+        ToolResult
+      >;
+
+      const result = await invocation.execute(abortSignal);
+      expect(result).toEqual({
+        llmContent:
+          'Could not read file because no file was found at the specified path.',
+        returnDisplay: 'File not found.',
+        error: {
+          message: `File not found: ${filePath}`,
+          type: ToolErrorType.FILE_NOT_FOUND,
+        },
+      });
+    });
+
+    it('should return success result for a text file', async () => {
+      const filePath = path.join(tempRootDir, 'textfile.txt');
+      const fileContent = 'This is a test file.';
+      await fsp.writeFile(filePath, fileContent, 'utf-8');
+      const params: ReadFileToolParams = { absolute_path: filePath };
+      const invocation = tool.build(params) as ToolInvocation<
+        ReadFileToolParams,
+        ToolResult
+      >;
+
+      expect(await invocation.execute(abortSignal)).toEqual({
+        llmContent: fileContent,
+        returnDisplay: '',
+      });
+    });
+
+    it('should return error if path is a directory', async () => {
+      const dirPath = path.join(tempRootDir, 'directory');
+      await fsp.mkdir(dirPath);
+      const params: ReadFileToolParams = { absolute_path: dirPath };
+      const invocation = tool.build(params) as ToolInvocation<
+        ReadFileToolParams,
+        ToolResult
+      >;
+
+      const result = await invocation.execute(abortSignal);
+      expect(result).toEqual({
+        llmContent:
+          'Could not read file because the provided path is a directory, not a file.',
+        returnDisplay: 'Path is a directory.',
+        error: {
+          message: `Path is a directory, not a file: ${dirPath}`,
+          type: ToolErrorType.INVALID_TOOL_PARAMS,
+        },
+      });
+    });
+
+    it('should return error for a file that is too large', async () => {
+      const filePath = path.join(tempRootDir, 'largefile.txt');
+      // 21MB of content exceeds 20MB limit
+      const largeContent = 'x'.repeat(21 * 1024 * 1024);
+      await fsp.writeFile(filePath, largeContent, 'utf-8');
+      const params: ReadFileToolParams = { absolute_path: filePath };
+      const invocation = tool.build(params) as ToolInvocation<
+        ReadFileToolParams,
+        ToolResult
+      >;
+
+      const result = await invocation.execute(abortSignal);
+      expect(result).toHaveProperty('error');
+      expect(result.error?.type).toBe(ToolErrorType.FILE_TOO_LARGE);
+      expect(result.error?.message).toContain(
+        'File size exceeds the 20MB limit',
+      );
+    });
+
+    it('should handle text file with lines exceeding maximum length', async () => {
+      const filePath = path.join(tempRootDir, 'longlines.txt');
+      const longLine = 'a'.repeat(2500); // Exceeds MAX_LINE_LENGTH_TEXT_FILE (2000)
+      const fileContent = `Short line\n${longLine}\nAnother short line`;
+      await fsp.writeFile(filePath, fileContent, 'utf-8');
+      const params: ReadFileToolParams = { absolute_path: filePath };
+      const invocation = tool.build(params) as ToolInvocation<
+        ReadFileToolParams,
+        ToolResult
+      >;
+
+      const result = await invocation.execute(abortSignal);
+      expect(result.llmContent).toContain(
+        'IMPORTANT: The file content has been truncated',
+      );
+      expect(result.llmContent).toContain('--- FILE CONTENT (truncated) ---');
+      expect(result.returnDisplay).toContain('some lines were shortened');
+    });
+
+    it('should handle image file and return appropriate content', async () => {
+      const imagePath = path.join(tempRootDir, 'image.png');
+      // Minimal PNG header
+      const pngHeader = Buffer.from([
+        0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a,
+      ]);
+      await fsp.writeFile(imagePath, pngHeader);
+      const params: ReadFileToolParams = { absolute_path: imagePath };
+      const invocation = tool.build(params) as ToolInvocation<
+        ReadFileToolParams,
+        ToolResult
+      >;
+
+      const result = await invocation.execute(abortSignal);
+      expect(result.llmContent).toEqual({
+        inlineData: {
+          data: pngHeader.toString('base64'),
+          mimeType: 'image/png',
+        },
+      });
+      expect(result.returnDisplay).toBe('Read image file: image.png');
+    });
+
+    it('should handle PDF file and return appropriate content', async () => {
+      const pdfPath = path.join(tempRootDir, 'document.pdf');
+      // Minimal PDF header
+      const pdfHeader = Buffer.from('%PDF-1.4');
+      await fsp.writeFile(pdfPath, pdfHeader);
+      const params: ReadFileToolParams = { absolute_path: pdfPath };
+      const invocation = tool.build(params) as ToolInvocation<
+        ReadFileToolParams,
+        ToolResult
+      >;
+
+      const result = await invocation.execute(abortSignal);
+      expect(result.llmContent).toEqual({
+        inlineData: {
+          data: pdfHeader.toString('base64'),
+          mimeType: 'application/pdf',
+        },
+      });
+      expect(result.returnDisplay).toBe('Read pdf file: document.pdf');
+    });
+
+    it('should handle binary file and skip content', async () => {
+      const binPath = path.join(tempRootDir, 'binary.bin');
+      // Binary data with null bytes
+      const binaryData = Buffer.from([0x00, 0xff, 0x00, 0xff]);
+      await fsp.writeFile(binPath, binaryData);
+      const params: ReadFileToolParams = { absolute_path: binPath };
+      const invocation = tool.build(params) as ToolInvocation<
+        ReadFileToolParams,
+        ToolResult
+      >;
+
+      const result = await invocation.execute(abortSignal);
+      expect(result.llmContent).toBe(
+        'Cannot display content of binary file: binary.bin',
+      );
+      expect(result.returnDisplay).toBe('Skipped binary file: binary.bin');
+    });
+
+    it('should handle SVG file as text', async () => {
+      const svgPath = path.join(tempRootDir, 'image.svg');
+      const svgContent = '<svg><circle cx="50" cy="50" r="40"/></svg>';
+      await fsp.writeFile(svgPath, svgContent, 'utf-8');
+      const params: ReadFileToolParams = { absolute_path: svgPath };
+      const invocation = tool.build(params) as ToolInvocation<
+        ReadFileToolParams,
+        ToolResult
+      >;
+
+      const result = await invocation.execute(abortSignal);
+      expect(result.llmContent).toBe(svgContent);
+      expect(result.returnDisplay).toBe('Read SVG as text: image.svg');
+    });
+
+    it('should handle large SVG file', async () => {
+      const svgPath = path.join(tempRootDir, 'large.svg');
+      // Create SVG content larger than 1MB
+      const largeContent = '<svg>' + 'x'.repeat(1024 * 1024 + 1) + '</svg>';
+      await fsp.writeFile(svgPath, largeContent, 'utf-8');
+      const params: ReadFileToolParams = { absolute_path: svgPath };
+      const invocation = tool.build(params) as ToolInvocation<
+        ReadFileToolParams,
+        ToolResult
+      >;
+
+      const result = await invocation.execute(abortSignal);
+      expect(result.llmContent).toBe(
+        'Cannot display content of SVG file larger than 1MB: large.svg',
+      );
+      expect(result.returnDisplay).toBe(
+        'Skipped large SVG file (>1MB): large.svg',
+      );
+    });
+
+    it('should handle empty file', async () => {
+      const emptyPath = path.join(tempRootDir, 'empty.txt');
+      await fsp.writeFile(emptyPath, '', 'utf-8');
+      const params: ReadFileToolParams = { absolute_path: emptyPath };
+      const invocation = tool.build(params) as ToolInvocation<
+        ReadFileToolParams,
+        ToolResult
+      >;
+
+      const result = await invocation.execute(abortSignal);
+      expect(result.llmContent).toBe('');
+      expect(result.returnDisplay).toBe('');
+    });
+
+    it('should support offset and limit for text files', async () => {
+      const filePath = path.join(tempRootDir, 'paginated.txt');
+      const lines = Array.from({ length: 20 }, (_, i) => `Line ${i + 1}`);
+      const fileContent = lines.join('\n');
+      await fsp.writeFile(filePath, fileContent, 'utf-8');
+
+      const params: ReadFileToolParams = {
+        absolute_path: filePath,
+        offset: 5, // Start from line 6
+        limit: 3,
+      };
+      const invocation = tool.build(params) as ToolInvocation<
+        ReadFileToolParams,
+        ToolResult
+      >;
+
+      const result = await invocation.execute(abortSignal);
+      expect(result.llmContent).toContain(
+        'IMPORTANT: The file content has been truncated',
+      );
+      expect(result.llmContent).toContain(
+        'Status: Showing lines 6-8 of 20 total lines',
+      );
+      expect(result.llmContent).toContain('Line 6');
+      expect(result.llmContent).toContain('Line 7');
+      expect(result.llmContent).toContain('Line 8');
+      expect(result.returnDisplay).toBe(
+        'Read lines 6-8 of 20 from paginated.txt',
+      );
+    });
+
+    describe('with .geminiignore', () => {
+      beforeEach(async () => {
+        await fsp.writeFile(
+          path.join(tempRootDir, '.geminiignore'),
+          ['foo.*', 'ignored/'].join('\n'),
+        );
+      });
+
+      it('should throw error if path is ignored by a .geminiignore pattern', async () => {
+        const ignoredFilePath = path.join(tempRootDir, 'foo.bar');
+        await fsp.writeFile(ignoredFilePath, 'content', 'utf-8');
+        const params: ReadFileToolParams = {
+          absolute_path: ignoredFilePath,
+        };
+        const expectedError = `File path '${ignoredFilePath}' is ignored by .geminiignore pattern(s).`;
+        expect(() => tool.build(params)).toThrow(expectedError);
+      });
+
+      it('should throw error if file is in an ignored directory', async () => {
+        const ignoredDirPath = path.join(tempRootDir, 'ignored');
+        await fsp.mkdir(ignoredDirPath, { recursive: true });
+        const ignoredFilePath = path.join(ignoredDirPath, 'file.txt');
+        await fsp.writeFile(ignoredFilePath, 'content', 'utf-8');
+        const params: ReadFileToolParams = {
+          absolute_path: ignoredFilePath,
+        };
+        const expectedError = `File path '${ignoredFilePath}' is ignored by .geminiignore pattern(s).`;
+        expect(() => tool.build(params)).toThrow(expectedError);
+      });
+
+      it('should allow reading non-ignored files', async () => {
+        const allowedFilePath = path.join(tempRootDir, 'allowed.txt');
+        await fsp.writeFile(allowedFilePath, 'content', 'utf-8');
+        const params: ReadFileToolParams = {
+          absolute_path: allowedFilePath,
+        };
+        const invocation = tool.build(params);
+        expect(typeof invocation).not.toBe('string');
+      });
+    });
+  });
+});

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

@@ -0,0 +1,238 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import path from 'path';
+import { makeRelative, shortenPath } from '../utils/paths.js';
+import {
+  BaseDeclarativeTool,
+  BaseToolInvocation,
+  Kind,
+  ToolInvocation,
+  ToolLocation,
+  ToolResult,
+} from './tools.js';
+import { ToolErrorType } from './tool-error.js';
+import { PartUnion } from '@google/genai';
+import {
+  processSingleFileContent,
+  getSpecificMimeType,
+} from '../utils/fileUtils.js';
+import { Config } from '../config/config.js';
+import {
+  recordFileOperationMetric,
+  FileOperation,
+} from '../telemetry/metrics.js';
+
+/**
+ * Parameters for the ReadFile tool
+ */
+export interface ReadFileToolParams {
+  /**
+   * The absolute path to the file to read
+   */
+  absolute_path: string;
+
+  /**
+   * The line number to start reading from (optional)
+   */
+  offset?: number;
+
+  /**
+   * The number of lines to read (optional)
+   */
+  limit?: number;
+}
+
+class ReadFileToolInvocation extends BaseToolInvocation<
+  ReadFileToolParams,
+  ToolResult
+> {
+  constructor(
+    private config: Config,
+    params: ReadFileToolParams,
+  ) {
+    super(params);
+  }
+
+  getDescription(): string {
+    const relativePath = makeRelative(
+      this.params.absolute_path,
+      this.config.getTargetDir(),
+    );
+    return shortenPath(relativePath);
+  }
+
+  override toolLocations(): ToolLocation[] {
+    return [{ path: this.params.absolute_path, line: this.params.offset }];
+  }
+
+  async execute(): Promise<ToolResult> {
+    const result = await processSingleFileContent(
+      this.params.absolute_path,
+      this.config.getTargetDir(),
+      this.config.getFileSystemService(),
+      this.params.offset,
+      this.params.limit,
+    );
+
+    if (result.error) {
+      // Map error messages to ToolErrorType
+      let errorType: ToolErrorType;
+      let llmContent: string;
+
+      // Check error message patterns to determine error type
+      if (
+        result.error.includes('File not found') ||
+        result.error.includes('does not exist') ||
+        result.error.includes('ENOENT')
+      ) {
+        errorType = ToolErrorType.FILE_NOT_FOUND;
+        llmContent =
+          'Could not read file because no file was found at the specified path.';
+      } else if (
+        result.error.includes('is a directory') ||
+        result.error.includes('EISDIR')
+      ) {
+        errorType = ToolErrorType.INVALID_TOOL_PARAMS;
+        llmContent =
+          'Could not read file because the provided path is a directory, not a file.';
+      } else if (
+        result.error.includes('too large') ||
+        result.error.includes('File size exceeds')
+      ) {
+        errorType = ToolErrorType.FILE_TOO_LARGE;
+        llmContent = `Could not read file. ${result.error}`;
+      } else {
+        // Other read errors map to READ_CONTENT_FAILURE
+        errorType = ToolErrorType.READ_CONTENT_FAILURE;
+        llmContent = `Could not read file. ${result.error}`;
+      }
+
+      return {
+        llmContent,
+        returnDisplay: result.returnDisplay || 'Error reading file',
+        error: {
+          message: result.error,
+          type: errorType,
+        },
+      };
+    }
+
+    let llmContent: PartUnion;
+    if (result.isTruncated) {
+      const [start, end] = result.linesShown!;
+      const total = result.originalLineCount!;
+      const nextOffset = this.params.offset
+        ? this.params.offset + end - start + 1
+        : end;
+      llmContent = `
+IMPORTANT: The file content has been truncated.
+Status: Showing lines ${start}-${end} of ${total} total lines.
+Action: To read more of the file, you can use the 'offset' and 'limit' parameters in a subsequent 'read_file' call. For example, to read the next section of the file, use offset: ${nextOffset}.
+
+--- FILE CONTENT (truncated) ---
+${result.llmContent}`;
+    } else {
+      llmContent = result.llmContent || '';
+    }
+
+    const lines =
+      typeof result.llmContent === 'string'
+        ? result.llmContent.split('\n').length
+        : undefined;
+    const mimetype = getSpecificMimeType(this.params.absolute_path);
+    recordFileOperationMetric(
+      this.config,
+      FileOperation.READ,
+      lines,
+      mimetype,
+      path.extname(this.params.absolute_path),
+    );
+
+    return {
+      llmContent,
+      returnDisplay: result.returnDisplay || '',
+    };
+  }
+}
+
+/**
+ * Implementation of the ReadFile tool logic
+ */
+export class ReadFileTool extends BaseDeclarativeTool<
+  ReadFileToolParams,
+  ToolResult
+> {
+  static readonly Name: string = 'read_file';
+
+  constructor(private config: Config) {
+    super(
+      ReadFileTool.Name,
+      'ReadFile',
+      `Reads and returns the content of a specified file. If the file is large, the content will be truncated. The tool's response will clearly indicate if truncation has occurred and will provide details on how to read more of the file using the 'offset' and 'limit' parameters. Handles text, images (PNG, JPG, GIF, WEBP, SVG, BMP), and PDF files. For text files, it can read specific line ranges.`,
+      Kind.Read,
+      {
+        properties: {
+          absolute_path: {
+            description:
+              "The absolute path to the file to read (e.g., '/home/user/project/file.txt'). Relative paths are not supported. You must provide an absolute path.",
+            type: 'string',
+          },
+          offset: {
+            description:
+              "Optional: For text files, the 0-based line number to start reading from. Requires 'limit' to be set. Use for paginating through large files.",
+            type: 'number',
+          },
+          limit: {
+            description:
+              "Optional: For text files, maximum number of lines to read. Use with 'offset' to paginate through large files. If omitted, reads the entire file (if feasible, up to a default limit).",
+            type: 'number',
+          },
+        },
+        required: ['absolute_path'],
+        type: 'object',
+      },
+    );
+  }
+
+  protected override validateToolParamValues(
+    params: ReadFileToolParams,
+  ): string | null {
+    const filePath = params.absolute_path;
+    if (params.absolute_path.trim() === '') {
+      return "The 'absolute_path' parameter must be non-empty.";
+    }
+
+    if (!path.isAbsolute(filePath)) {
+      return `File path must be absolute, but was relative: ${filePath}. You must provide an absolute path.`;
+    }
+
+    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(', ')}`;
+    }
+    if (params.offset !== undefined && params.offset < 0) {
+      return 'Offset must be a non-negative number';
+    }
+    if (params.limit !== undefined && params.limit <= 0) {
+      return 'Limit must be a positive number';
+    }
+
+    const fileService = this.config.getFileService();
+    if (fileService.shouldGeminiIgnoreFile(params.absolute_path)) {
+      return `File path '${filePath}' is ignored by .geminiignore pattern(s).`;
+    }
+
+    return null;
+  }
+
+  protected createInvocation(
+    params: ReadFileToolParams,
+  ): ToolInvocation<ReadFileToolParams, ToolResult> {
+    return new ReadFileToolInvocation(this.config, params);
+  }
+}

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

@@ -0,0 +1,696 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { vi, describe, it, expect, beforeEach, afterEach } from 'vitest';
+import type { Mock } from 'vitest';
+import { mockControl } from '../__mocks__/fs/promises.js';
+import { ReadManyFilesTool } from './read-many-files.js';
+import { FileDiscoveryService } from '../services/fileDiscoveryService.js';
+import path from 'path';
+import fs from 'fs'; // Actual fs for setup
+import os from 'os';
+import { Config } from '../config/config.js';
+import { WorkspaceContext } from '../utils/workspaceContext.js';
+import { StandardFileSystemService } from '../services/fileSystemService.js';
+
+vi.mock('mime-types', () => {
+  const lookup = (filename: string) => {
+    if (filename.endsWith('.ts') || filename.endsWith('.js')) {
+      return 'text/plain';
+    }
+    if (filename.endsWith('.png')) {
+      return 'image/png';
+    }
+    if (filename.endsWith('.pdf')) {
+      return 'application/pdf';
+    }
+    if (filename.endsWith('.mp3') || filename.endsWith('.wav')) {
+      return 'audio/mpeg';
+    }
+    if (filename.endsWith('.mp4') || filename.endsWith('.mov')) {
+      return 'video/mp4';
+    }
+    return false;
+  };
+  return {
+    default: {
+      lookup,
+    },
+    lookup,
+  };
+});
+
+describe('ReadManyFilesTool', () => {
+  let tool: ReadManyFilesTool;
+  let tempRootDir: string;
+  let tempDirOutsideRoot: string;
+  let mockReadFileFn: Mock;
+
+  beforeEach(async () => {
+    tempRootDir = fs.realpathSync(
+      fs.mkdtempSync(path.join(os.tmpdir(), 'read-many-files-root-')),
+    );
+    tempDirOutsideRoot = fs.realpathSync(
+      fs.mkdtempSync(path.join(os.tmpdir(), 'read-many-files-external-')),
+    );
+    fs.writeFileSync(path.join(tempRootDir, '.geminiignore'), 'foo.*');
+    const fileService = new FileDiscoveryService(tempRootDir);
+    const mockConfig = {
+      getFileService: () => fileService,
+      getFileSystemService: () => new StandardFileSystemService(),
+
+      getFileFilteringOptions: () => ({
+        respectGitIgnore: true,
+        respectGeminiIgnore: true,
+      }),
+      getTargetDir: () => tempRootDir,
+      getWorkspaceDirs: () => [tempRootDir],
+      getWorkspaceContext: () => new WorkspaceContext(tempRootDir),
+    } as Partial<Config> as Config;
+    tool = new ReadManyFilesTool(mockConfig);
+
+    mockReadFileFn = mockControl.mockReadFile;
+    mockReadFileFn.mockReset();
+
+    mockReadFileFn.mockImplementation(
+      async (filePath: fs.PathLike, options?: Record<string, unknown>) => {
+        const fp =
+          typeof filePath === 'string'
+            ? filePath
+            : (filePath as Buffer).toString();
+
+        if (fs.existsSync(fp)) {
+          const originalFs = await vi.importActual<typeof fs>('fs');
+          return originalFs.promises.readFile(fp, options);
+        }
+
+        if (fp.endsWith('nonexistent-file.txt')) {
+          const err = new Error(
+            `ENOENT: no such file or directory, open '${fp}'`,
+          );
+          (err as NodeJS.ErrnoException).code = 'ENOENT';
+          throw err;
+        }
+        if (fp.endsWith('unreadable.txt')) {
+          const err = new Error(`EACCES: permission denied, open '${fp}'`);
+          (err as NodeJS.ErrnoException).code = 'EACCES';
+          throw err;
+        }
+        if (fp.endsWith('.png'))
+          return Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]); // PNG header
+        if (fp.endsWith('.pdf')) return Buffer.from('%PDF-1.4...'); // PDF start
+        if (fp.endsWith('binary.bin'))
+          return Buffer.from([0x00, 0x01, 0x02, 0x00, 0x03]);
+
+        const err = new Error(
+          `ENOENT: no such file or directory, open '${fp}' (unmocked path)`,
+        );
+        (err as NodeJS.ErrnoException).code = 'ENOENT';
+        throw err;
+      },
+    );
+  });
+
+  afterEach(() => {
+    if (fs.existsSync(tempRootDir)) {
+      fs.rmSync(tempRootDir, { recursive: true, force: true });
+    }
+    if (fs.existsSync(tempDirOutsideRoot)) {
+      fs.rmSync(tempDirOutsideRoot, { recursive: true, force: true });
+    }
+  });
+
+  describe('build', () => {
+    it('should return an invocation for valid relative paths within root', () => {
+      const params = { paths: ['file1.txt', 'subdir/file2.txt'] };
+      const invocation = tool.build(params);
+      expect(invocation).toBeDefined();
+    });
+
+    it('should return an invocation for valid glob patterns within root', () => {
+      const params = { paths: ['*.txt', 'subdir/**/*.js'] };
+      const invocation = tool.build(params);
+      expect(invocation).toBeDefined();
+    });
+
+    it('should return an invocation for paths trying to escape the root (e.g., ../) as execute handles this', () => {
+      const params = { paths: ['../outside.txt'] };
+      const invocation = tool.build(params);
+      expect(invocation).toBeDefined();
+    });
+
+    it('should return an invocation for absolute paths as execute handles this', () => {
+      const params = { paths: [path.join(tempDirOutsideRoot, 'absolute.txt')] };
+      const invocation = tool.build(params);
+      expect(invocation).toBeDefined();
+    });
+
+    it('should throw error if paths array is empty', () => {
+      const params = { paths: [] };
+      expect(() => tool.build(params)).toThrow(
+        'params/paths must NOT have fewer than 1 items',
+      );
+    });
+
+    it('should return an invocation for valid exclude and include patterns', () => {
+      const params = {
+        paths: ['src/**/*.ts'],
+        exclude: ['**/*.test.ts'],
+        include: ['src/utils/*.ts'],
+      };
+      const invocation = tool.build(params);
+      expect(invocation).toBeDefined();
+    });
+
+    it('should throw error if paths array contains an empty string', () => {
+      const params = { paths: ['file1.txt', ''] };
+      expect(() => tool.build(params)).toThrow(
+        'params/paths/1 must NOT have fewer than 1 characters',
+      );
+    });
+
+    it('should throw error if include array contains non-string elements', () => {
+      const params = {
+        paths: ['file1.txt'],
+        include: ['*.ts', 123] as string[],
+      };
+      expect(() => tool.build(params)).toThrow(
+        'params/include/1 must be string',
+      );
+    });
+
+    it('should throw error if exclude array contains non-string elements', () => {
+      const params = {
+        paths: ['file1.txt'],
+        exclude: ['*.log', {}] as string[],
+      };
+      expect(() => tool.build(params)).toThrow(
+        'params/exclude/1 must be string',
+      );
+    });
+  });
+
+  describe('execute', () => {
+    const createFile = (filePath: string, content = '') => {
+      const fullPath = path.join(tempRootDir, filePath);
+      fs.mkdirSync(path.dirname(fullPath), { recursive: true });
+      fs.writeFileSync(fullPath, content);
+    };
+    const createBinaryFile = (filePath: string, data: Uint8Array) => {
+      const fullPath = path.join(tempRootDir, filePath);
+      fs.mkdirSync(path.dirname(fullPath), { recursive: true });
+      fs.writeFileSync(fullPath, data);
+    };
+
+    it('should read a single specified file', async () => {
+      createFile('file1.txt', 'Content of file1');
+      const params = { paths: ['file1.txt'] };
+      const invocation = tool.build(params);
+      const result = await invocation.execute(new AbortController().signal);
+      const expectedPath = path.join(tempRootDir, 'file1.txt');
+      expect(result.llmContent).toEqual([
+        `--- ${expectedPath} ---\n\nContent of file1\n\n`,
+      ]);
+      expect(result.returnDisplay).toContain(
+        'Successfully read and concatenated content from **1 file(s)**',
+      );
+    });
+
+    it('should read multiple specified files', async () => {
+      createFile('file1.txt', 'Content1');
+      createFile('subdir/file2.js', 'Content2');
+      const params = { paths: ['file1.txt', 'subdir/file2.js'] };
+      const invocation = tool.build(params);
+      const result = await invocation.execute(new AbortController().signal);
+      const content = result.llmContent as string[];
+      const expectedPath1 = path.join(tempRootDir, 'file1.txt');
+      const expectedPath2 = path.join(tempRootDir, 'subdir/file2.js');
+      expect(
+        content.some((c) =>
+          c.includes(`--- ${expectedPath1} ---\n\nContent1\n\n`),
+        ),
+      ).toBe(true);
+      expect(
+        content.some((c) =>
+          c.includes(`--- ${expectedPath2} ---\n\nContent2\n\n`),
+        ),
+      ).toBe(true);
+      expect(result.returnDisplay).toContain(
+        'Successfully read and concatenated content from **2 file(s)**',
+      );
+    });
+
+    it('should handle glob patterns', async () => {
+      createFile('file.txt', 'Text file');
+      createFile('another.txt', 'Another text');
+      createFile('sub/data.json', '{}');
+      const params = { paths: ['*.txt'] };
+      const invocation = tool.build(params);
+      const result = await invocation.execute(new AbortController().signal);
+      const content = result.llmContent as string[];
+      const expectedPath1 = path.join(tempRootDir, 'file.txt');
+      const expectedPath2 = path.join(tempRootDir, 'another.txt');
+      expect(
+        content.some((c) =>
+          c.includes(`--- ${expectedPath1} ---\n\nText file\n\n`),
+        ),
+      ).toBe(true);
+      expect(
+        content.some((c) =>
+          c.includes(`--- ${expectedPath2} ---\n\nAnother text\n\n`),
+        ),
+      ).toBe(true);
+      expect(content.find((c) => c.includes('sub/data.json'))).toBeUndefined();
+      expect(result.returnDisplay).toContain(
+        'Successfully read and concatenated content from **2 file(s)**',
+      );
+    });
+
+    it('should respect exclude patterns', async () => {
+      createFile('src/main.ts', 'Main content');
+      createFile('src/main.test.ts', 'Test content');
+      const params = { paths: ['src/**/*.ts'], exclude: ['**/*.test.ts'] };
+      const invocation = tool.build(params);
+      const result = await invocation.execute(new AbortController().signal);
+      const content = result.llmContent as string[];
+      const expectedPath = path.join(tempRootDir, 'src/main.ts');
+      expect(content).toEqual([`--- ${expectedPath} ---\n\nMain content\n\n`]);
+      expect(
+        content.find((c) => c.includes('src/main.test.ts')),
+      ).toBeUndefined();
+      expect(result.returnDisplay).toContain(
+        'Successfully read and concatenated content from **1 file(s)**',
+      );
+    });
+
+    it('should handle nonexistent specific files gracefully', async () => {
+      const params = { paths: ['nonexistent-file.txt'] };
+      const invocation = tool.build(params);
+      const result = await invocation.execute(new AbortController().signal);
+      expect(result.llmContent).toEqual([
+        'No files matching the criteria were found or all were skipped.',
+      ]);
+      expect(result.returnDisplay).toContain(
+        'No files were read and concatenated based on the criteria.',
+      );
+    });
+
+    it('should use default excludes', async () => {
+      createFile('node_modules/some-lib/index.js', 'lib code');
+      createFile('src/app.js', 'app code');
+      const params = { paths: ['**/*.js'] };
+      const invocation = tool.build(params);
+      const result = await invocation.execute(new AbortController().signal);
+      const content = result.llmContent as string[];
+      const expectedPath = path.join(tempRootDir, 'src/app.js');
+      expect(content).toEqual([`--- ${expectedPath} ---\n\napp code\n\n`]);
+      expect(
+        content.find((c) => c.includes('node_modules/some-lib/index.js')),
+      ).toBeUndefined();
+      expect(result.returnDisplay).toContain(
+        'Successfully read and concatenated content from **1 file(s)**',
+      );
+    });
+
+    it('should NOT use default excludes if useDefaultExcludes is false', async () => {
+      createFile('node_modules/some-lib/index.js', 'lib code');
+      createFile('src/app.js', 'app code');
+      const params = { paths: ['**/*.js'], useDefaultExcludes: false };
+      const invocation = tool.build(params);
+      const result = await invocation.execute(new AbortController().signal);
+      const content = result.llmContent as string[];
+      const expectedPath1 = path.join(
+        tempRootDir,
+        'node_modules/some-lib/index.js',
+      );
+      const expectedPath2 = path.join(tempRootDir, 'src/app.js');
+      expect(
+        content.some((c) =>
+          c.includes(`--- ${expectedPath1} ---\n\nlib code\n\n`),
+        ),
+      ).toBe(true);
+      expect(
+        content.some((c) =>
+          c.includes(`--- ${expectedPath2} ---\n\napp code\n\n`),
+        ),
+      ).toBe(true);
+      expect(result.returnDisplay).toContain(
+        'Successfully read and concatenated content from **2 file(s)**',
+      );
+    });
+
+    it('should include images as inlineData parts if explicitly requested by extension', async () => {
+      createBinaryFile(
+        'image.png',
+        Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]),
+      );
+      const params = { paths: ['*.png'] }; // Explicitly requesting .png
+      const invocation = tool.build(params);
+      const result = await invocation.execute(new AbortController().signal);
+      expect(result.llmContent).toEqual([
+        {
+          inlineData: {
+            data: Buffer.from([
+              0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a,
+            ]).toString('base64'),
+            mimeType: 'image/png',
+          },
+        },
+      ]);
+      expect(result.returnDisplay).toContain(
+        'Successfully read and concatenated content from **1 file(s)**',
+      );
+    });
+
+    it('should include images as inlineData parts if explicitly requested by name', async () => {
+      createBinaryFile(
+        'myExactImage.png',
+        Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]),
+      );
+      const params = { paths: ['myExactImage.png'] }; // Explicitly requesting by full name
+      const invocation = tool.build(params);
+      const result = await invocation.execute(new AbortController().signal);
+      expect(result.llmContent).toEqual([
+        {
+          inlineData: {
+            data: Buffer.from([
+              0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a,
+            ]).toString('base64'),
+            mimeType: 'image/png',
+          },
+        },
+      ]);
+    });
+
+    it('should skip PDF files if not explicitly requested by extension or name', async () => {
+      createBinaryFile('document.pdf', Buffer.from('%PDF-1.4...'));
+      createFile('notes.txt', 'text notes');
+      const params = { paths: ['*'] }; // Generic glob, not specific to .pdf
+      const invocation = tool.build(params);
+      const result = await invocation.execute(new AbortController().signal);
+      const content = result.llmContent as string[];
+      const expectedPath = path.join(tempRootDir, 'notes.txt');
+      expect(
+        content.some(
+          (c) =>
+            typeof c === 'string' &&
+            c.includes(`--- ${expectedPath} ---\n\ntext notes\n\n`),
+        ),
+      ).toBe(true);
+      expect(result.returnDisplay).toContain('**Skipped 1 item(s):**');
+      expect(result.returnDisplay).toContain(
+        '- `document.pdf` (Reason: asset file (image/pdf) was not explicitly requested by name or extension)',
+      );
+    });
+
+    it('should include PDF files as inlineData parts if explicitly requested by extension', async () => {
+      createBinaryFile('important.pdf', Buffer.from('%PDF-1.4...'));
+      const params = { paths: ['*.pdf'] }; // Explicitly requesting .pdf files
+      const invocation = tool.build(params);
+      const result = await invocation.execute(new AbortController().signal);
+      expect(result.llmContent).toEqual([
+        {
+          inlineData: {
+            data: Buffer.from('%PDF-1.4...').toString('base64'),
+            mimeType: 'application/pdf',
+          },
+        },
+      ]);
+    });
+
+    it('should include PDF files as inlineData parts if explicitly requested by name', async () => {
+      createBinaryFile('report-final.pdf', Buffer.from('%PDF-1.4...'));
+      const params = { paths: ['report-final.pdf'] };
+      const invocation = tool.build(params);
+      const result = await invocation.execute(new AbortController().signal);
+      expect(result.llmContent).toEqual([
+        {
+          inlineData: {
+            data: Buffer.from('%PDF-1.4...').toString('base64'),
+            mimeType: 'application/pdf',
+          },
+        },
+      ]);
+    });
+
+    it('should return error if path is ignored by a .geminiignore pattern', async () => {
+      createFile('foo.bar', '');
+      createFile('bar.ts', '');
+      createFile('foo.quux', '');
+      const params = { paths: ['foo.bar', 'bar.ts', 'foo.quux'] };
+      const invocation = tool.build(params);
+      const result = await invocation.execute(new AbortController().signal);
+      expect(result.returnDisplay).not.toContain('foo.bar');
+      expect(result.returnDisplay).not.toContain('foo.quux');
+      expect(result.returnDisplay).toContain('bar.ts');
+    });
+
+    it('should read files from multiple workspace directories', async () => {
+      const tempDir1 = fs.realpathSync(
+        fs.mkdtempSync(path.join(os.tmpdir(), 'multi-dir-1-')),
+      );
+      const tempDir2 = fs.realpathSync(
+        fs.mkdtempSync(path.join(os.tmpdir(), 'multi-dir-2-')),
+      );
+      const fileService = new FileDiscoveryService(tempDir1);
+      const mockConfig = {
+        getFileService: () => fileService,
+        getFileSystemService: () => new StandardFileSystemService(),
+        getFileFilteringOptions: () => ({
+          respectGitIgnore: true,
+          respectGeminiIgnore: true,
+        }),
+        getWorkspaceContext: () => new WorkspaceContext(tempDir1, [tempDir2]),
+        getTargetDir: () => tempDir1,
+      } as Partial<Config> as Config;
+      tool = new ReadManyFilesTool(mockConfig);
+
+      fs.writeFileSync(path.join(tempDir1, 'file1.txt'), 'Content1');
+      fs.writeFileSync(path.join(tempDir2, 'file2.txt'), 'Content2');
+
+      const params = { paths: ['*.txt'] };
+      const invocation = tool.build(params);
+      const result = await invocation.execute(new AbortController().signal);
+      const content = result.llmContent as string[];
+      if (!Array.isArray(content)) {
+        throw new Error(`llmContent is not an array: ${content}`);
+      }
+      const expectedPath1 = path.join(tempDir1, 'file1.txt');
+      const expectedPath2 = path.join(tempDir2, 'file2.txt');
+
+      expect(
+        content.some((c) =>
+          c.includes(`--- ${expectedPath1} ---\n\nContent1\n\n`),
+        ),
+      ).toBe(true);
+      expect(
+        content.some((c) =>
+          c.includes(`--- ${expectedPath2} ---\n\nContent2\n\n`),
+        ),
+      ).toBe(true);
+      expect(result.returnDisplay).toContain(
+        'Successfully read and concatenated content from **2 file(s)**',
+      );
+
+      fs.rmSync(tempDir1, { recursive: true, force: true });
+      fs.rmSync(tempDir2, { recursive: true, force: true });
+    });
+
+    it('should add a warning for truncated files', async () => {
+      createFile('file1.txt', 'Content1');
+      // Create a file that will be "truncated" by making it long
+      const longContent = Array.from({ length: 2500 }, (_, i) => `L${i}`).join(
+        '\n',
+      );
+      createFile('large-file.txt', longContent);
+
+      const params = { paths: ['*.txt'] };
+      const invocation = tool.build(params);
+      const result = await invocation.execute(new AbortController().signal);
+      const content = result.llmContent as string[];
+
+      const normalFileContent = content.find((c) => c.includes('file1.txt'));
+      const truncatedFileContent = content.find((c) =>
+        c.includes('large-file.txt'),
+      );
+
+      expect(normalFileContent).not.toContain(
+        '[WARNING: This file was truncated.',
+      );
+      expect(truncatedFileContent).toContain(
+        "[WARNING: This file was truncated. To view the full content, use the 'read_file' tool on this specific file.]",
+      );
+      // Check that the actual content is still there but truncated
+      expect(truncatedFileContent).toContain('L200');
+      expect(truncatedFileContent).not.toContain('L2400');
+    });
+
+    it('should read files with special characters like [] and () in the path', async () => {
+      const filePath = 'src/app/[test]/(dashboard)/testing/components/code.tsx';
+      createFile(filePath, 'Content of receive-detail');
+      const params = { paths: [filePath] };
+      const invocation = tool.build(params);
+      const result = await invocation.execute(new AbortController().signal);
+      const expectedPath = path.join(tempRootDir, filePath);
+      expect(result.llmContent).toEqual([
+        `--- ${expectedPath} ---
+
+Content of receive-detail
+
+`,
+      ]);
+      expect(result.returnDisplay).toContain(
+        'Successfully read and concatenated content from **1 file(s)**',
+      );
+    });
+
+    it('should read files with special characters in the name', async () => {
+      createFile('file[1].txt', 'Content of file[1]');
+      const params = { paths: ['file[1].txt'] };
+      const invocation = tool.build(params);
+      const result = await invocation.execute(new AbortController().signal);
+      const expectedPath = path.join(tempRootDir, 'file[1].txt');
+      expect(result.llmContent).toEqual([
+        `--- ${expectedPath} ---
+
+Content of file[1]
+
+`,
+      ]);
+      expect(result.returnDisplay).toContain(
+        'Successfully read and concatenated content from **1 file(s)**',
+      );
+    });
+  });
+
+  describe('Batch Processing', () => {
+    const createMultipleFiles = (count: number, contentPrefix = 'Content') => {
+      const files: string[] = [];
+      for (let i = 0; i < count; i++) {
+        const fileName = `file${i}.txt`;
+        createFile(fileName, `${contentPrefix} ${i}`);
+        files.push(fileName);
+      }
+      return files;
+    };
+
+    const createFile = (filePath: string, content = '') => {
+      const fullPath = path.join(tempRootDir, filePath);
+      fs.mkdirSync(path.dirname(fullPath), { recursive: true });
+      fs.writeFileSync(fullPath, content);
+    };
+
+    it('should process files in parallel', async () => {
+      // Mock detectFileType to add artificial delay to simulate I/O
+      const detectFileTypeSpy = vi.spyOn(
+        await import('../utils/fileUtils.js'),
+        'detectFileType',
+      );
+
+      // Create files
+      const fileCount = 4;
+      const files = createMultipleFiles(fileCount, 'Batch test');
+
+      // Mock with 10ms delay per file to simulate I/O operations
+      detectFileTypeSpy.mockImplementation(async (_filePath: string) => {
+        await new Promise((resolve) => setTimeout(resolve, 10));
+        return 'text';
+      });
+
+      const params = { paths: files };
+      const invocation = tool.build(params);
+      const result = await invocation.execute(new AbortController().signal);
+
+      // Verify all files were processed
+      const content = result.llmContent as string[];
+      expect(content).toHaveLength(fileCount);
+      for (let i = 0; i < fileCount; i++) {
+        expect(content.join('')).toContain(`Batch test ${i}`);
+      }
+
+      // Cleanup mock
+      detectFileTypeSpy.mockRestore();
+    });
+
+    it('should handle batch processing errors gracefully', async () => {
+      // Create mix of valid and problematic files
+      createFile('valid1.txt', 'Valid content 1');
+      createFile('valid2.txt', 'Valid content 2');
+      createFile('valid3.txt', 'Valid content 3');
+
+      const params = {
+        paths: [
+          'valid1.txt',
+          'valid2.txt',
+          'nonexistent-file.txt', // This will fail
+          'valid3.txt',
+        ],
+      };
+
+      const invocation = tool.build(params);
+      const result = await invocation.execute(new AbortController().signal);
+      const content = result.llmContent as string[];
+
+      // Should successfully process valid files despite one failure
+      expect(content.length).toBeGreaterThanOrEqual(3);
+      expect(result.returnDisplay).toContain('Successfully read');
+
+      // Verify valid files were processed
+      const expectedPath1 = path.join(tempRootDir, 'valid1.txt');
+      const expectedPath3 = path.join(tempRootDir, 'valid3.txt');
+      expect(content.some((c) => c.includes(expectedPath1))).toBe(true);
+      expect(content.some((c) => c.includes(expectedPath3))).toBe(true);
+    });
+
+    it('should execute file operations concurrently', async () => {
+      // Track execution order to verify concurrency
+      const executionOrder: string[] = [];
+      const detectFileTypeSpy = vi.spyOn(
+        await import('../utils/fileUtils.js'),
+        'detectFileType',
+      );
+
+      const files = ['file1.txt', 'file2.txt', 'file3.txt'];
+      files.forEach((file) => createFile(file, 'test content'));
+
+      // Mock to track concurrent vs sequential execution
+      detectFileTypeSpy.mockImplementation(async (filePath: string) => {
+        const fileName = filePath.split('/').pop() || '';
+        executionOrder.push(`start:${fileName}`);
+
+        // Add delay to make timing differences visible
+        await new Promise((resolve) => setTimeout(resolve, 50));
+
+        executionOrder.push(`end:${fileName}`);
+        return 'text';
+      });
+
+      const invocation = tool.build({ paths: files });
+      await invocation.execute(new AbortController().signal);
+
+      console.log('Execution order:', executionOrder);
+
+      // Verify concurrent execution pattern
+      // In parallel execution: all "start:" events should come before all "end:" events
+      // In sequential execution: "start:file1", "end:file1", "start:file2", "end:file2", etc.
+
+      const startEvents = executionOrder.filter((e) =>
+        e.startsWith('start:'),
+      ).length;
+      const firstEndIndex = executionOrder.findIndex((e) =>
+        e.startsWith('end:'),
+      );
+      const startsBeforeFirstEnd = executionOrder
+        .slice(0, firstEndIndex)
+        .filter((e) => e.startsWith('start:')).length;
+
+      // For parallel processing, ALL start events should happen before the first end event
+      expect(startsBeforeFirstEnd).toBe(startEvents); // Should PASS with parallel implementation
+
+      detectFileTypeSpy.mockRestore();
+    });
+  });
+});

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

@@ -0,0 +1,644 @@
+/**
+ * @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 * as fs from 'fs';
+import * as path from 'path';
+import { glob, escape } from 'glob';
+import { getCurrentGeminiMdFilename } from './memoryTool.js';
+import {
+  detectFileType,
+  processSingleFileContent,
+  DEFAULT_ENCODING,
+  getSpecificMimeType,
+} from '../utils/fileUtils.js';
+import { PartListUnion } from '@google/genai';
+import { Config, DEFAULT_FILE_FILTERING_OPTIONS } from '../config/config.js';
+import {
+  recordFileOperationMetric,
+  FileOperation,
+} from '../telemetry/metrics.js';
+
+/**
+ * Parameters for the ReadManyFilesTool.
+ */
+export interface ReadManyFilesParams {
+  /**
+   * An array of file paths or directory paths to search within.
+   * Paths are relative to the tool's configured target directory.
+   * Glob patterns can be used directly in these paths.
+   */
+  paths: string[];
+
+  /**
+   * Optional. Glob patterns for files to include.
+   * These are effectively combined with the `paths`.
+   * Example: ["*.ts", "src/** /*.md"]
+   */
+  include?: string[];
+
+  /**
+   * Optional. Glob patterns for files/directories to exclude.
+   * Applied as ignore patterns.
+   * Example: ["*.log", "dist/**"]
+   */
+  exclude?: string[];
+
+  /**
+   * Optional. Search directories recursively.
+   * This is generally controlled by glob patterns (e.g., `**`).
+   * The glob implementation is recursive by default for `**`.
+   * For simplicity, we'll rely on `**` for recursion.
+   */
+  recursive?: boolean;
+
+  /**
+   * Optional. Apply default exclusion patterns. Defaults to true.
+   */
+  useDefaultExcludes?: boolean;
+
+  /**
+   * Whether to respect .gitignore and .geminiignore patterns (optional, defaults to true)
+   */
+  file_filtering_options?: {
+    respect_git_ignore?: boolean;
+    respect_gemini_ignore?: boolean;
+  };
+}
+
+/**
+ * Result type for file processing operations
+ */
+type FileProcessingResult =
+  | {
+      success: true;
+      filePath: string;
+      relativePathForDisplay: string;
+      fileReadResult: NonNullable<
+        Awaited<ReturnType<typeof processSingleFileContent>>
+      >;
+      reason?: undefined;
+    }
+  | {
+      success: false;
+      filePath: string;
+      relativePathForDisplay: string;
+      fileReadResult?: undefined;
+      reason: string;
+    };
+
+/**
+ * Default exclusion patterns for commonly ignored directories and binary file types.
+ * These are compatible with glob ignore patterns.
+ * TODO(adh): Consider making this configurable or extendable through a command line argument.
+ * TODO(adh): Look into sharing this list with the glob tool.
+ */
+const DEFAULT_EXCLUDES: string[] = [
+  '**/node_modules/**',
+  '**/.git/**',
+  '**/.vscode/**',
+  '**/.idea/**',
+  '**/dist/**',
+  '**/build/**',
+  '**/coverage/**',
+  '**/__pycache__/**',
+  '**/*.pyc',
+  '**/*.pyo',
+  '**/*.bin',
+  '**/*.exe',
+  '**/*.dll',
+  '**/*.so',
+  '**/*.dylib',
+  '**/*.class',
+  '**/*.jar',
+  '**/*.war',
+  '**/*.zip',
+  '**/*.tar',
+  '**/*.gz',
+  '**/*.bz2',
+  '**/*.rar',
+  '**/*.7z',
+  '**/*.doc',
+  '**/*.docx',
+  '**/*.xls',
+  '**/*.xlsx',
+  '**/*.ppt',
+  '**/*.pptx',
+  '**/*.odt',
+  '**/*.ods',
+  '**/*.odp',
+  '**/*.DS_Store',
+  '**/.env',
+  `**/${getCurrentGeminiMdFilename()}`,
+];
+
+const DEFAULT_OUTPUT_SEPARATOR_FORMAT = '--- {filePath} ---';
+
+class ReadManyFilesToolInvocation extends BaseToolInvocation<
+  ReadManyFilesParams,
+  ToolResult
+> {
+  constructor(
+    private readonly config: Config,
+    params: ReadManyFilesParams,
+  ) {
+    super(params);
+  }
+
+  getDescription(): string {
+    const allPatterns = [...this.params.paths, ...(this.params.include || [])];
+    const pathDesc = `using patterns: 
+${allPatterns.join('`, `')}
+ (within target directory: 
+${this.config.getTargetDir()}
+) `;
+
+    // Determine the final list of exclusion patterns exactly as in execute method
+    const paramExcludes = this.params.exclude || [];
+    const paramUseDefaultExcludes = this.params.useDefaultExcludes !== false;
+    const geminiIgnorePatterns = this.config
+      .getFileService()
+      .getGeminiIgnorePatterns();
+    const finalExclusionPatternsForDescription: string[] =
+      paramUseDefaultExcludes
+        ? [...DEFAULT_EXCLUDES, ...paramExcludes, ...geminiIgnorePatterns]
+        : [...paramExcludes, ...geminiIgnorePatterns];
+
+    let excludeDesc = `Excluding: ${
+      finalExclusionPatternsForDescription.length > 0
+        ? `patterns like 
+${finalExclusionPatternsForDescription
+  .slice(0, 2)
+  .join(
+    '`, `',
+  )}${finalExclusionPatternsForDescription.length > 2 ? '...`' : '`'}`
+        : 'none specified'
+    }`;
+
+    // Add a note if .geminiignore patterns contributed to the final list of exclusions
+    if (geminiIgnorePatterns.length > 0) {
+      const geminiPatternsInEffect = geminiIgnorePatterns.filter((p) =>
+        finalExclusionPatternsForDescription.includes(p),
+      ).length;
+      if (geminiPatternsInEffect > 0) {
+        excludeDesc += ` (includes ${geminiPatternsInEffect} from .geminiignore)`;
+      }
+    }
+
+    return `Will attempt to read and concatenate files ${pathDesc}. ${excludeDesc}. File encoding: ${DEFAULT_ENCODING}. Separator: "${DEFAULT_OUTPUT_SEPARATOR_FORMAT.replace(
+      '{filePath}',
+      'path/to/file.ext',
+    )}".`;
+  }
+
+  async execute(signal: AbortSignal): Promise<ToolResult> {
+    const {
+      paths: inputPatterns,
+      include = [],
+      exclude = [],
+      useDefaultExcludes = true,
+    } = this.params;
+
+    const defaultFileIgnores =
+      this.config.getFileFilteringOptions() ?? DEFAULT_FILE_FILTERING_OPTIONS;
+
+    const fileFilteringOptions = {
+      respectGitIgnore:
+        this.params.file_filtering_options?.respect_git_ignore ??
+        defaultFileIgnores.respectGitIgnore, // Use the property from the returned object
+      respectGeminiIgnore:
+        this.params.file_filtering_options?.respect_gemini_ignore ??
+        defaultFileIgnores.respectGeminiIgnore, // Use the property from the returned object
+    };
+    // Get centralized file discovery service
+    const fileDiscovery = this.config.getFileService();
+
+    const filesToConsider = new Set<string>();
+    const skippedFiles: Array<{ path: string; reason: string }> = [];
+    const processedFilesRelativePaths: string[] = [];
+    const contentParts: PartListUnion = [];
+
+    const effectiveExcludes = useDefaultExcludes
+      ? [...DEFAULT_EXCLUDES, ...exclude]
+      : [...exclude];
+
+    const searchPatterns = [...inputPatterns, ...include];
+    if (searchPatterns.length === 0) {
+      return {
+        llmContent: 'No search paths or include patterns provided.',
+        returnDisplay: `## Information\n\nNo search paths or include patterns were specified. Nothing to read or concatenate.`,
+      };
+    }
+
+    try {
+      const allEntries = new Set<string>();
+      const workspaceDirs = this.config.getWorkspaceContext().getDirectories();
+
+      for (const dir of workspaceDirs) {
+        const processedPatterns = [];
+        for (const p of searchPatterns) {
+          const normalizedP = p.replace(/\\/g, '/');
+          const fullPath = path.join(dir, normalizedP);
+          if (fs.existsSync(fullPath)) {
+            processedPatterns.push(escape(normalizedP));
+          } else {
+            // The path does not exist or is not a file, so we treat it as a glob pattern.
+            processedPatterns.push(normalizedP);
+          }
+        }
+
+        const entriesInDir = await glob(processedPatterns, {
+          cwd: dir,
+          ignore: effectiveExcludes,
+          nodir: true,
+          dot: true,
+          absolute: true,
+          nocase: true,
+          signal,
+        });
+        for (const entry of entriesInDir) {
+          allEntries.add(entry);
+        }
+      }
+      const entries = Array.from(allEntries);
+
+      const gitFilteredEntries = fileFilteringOptions.respectGitIgnore
+        ? fileDiscovery
+            .filterFiles(
+              entries.map((p) => path.relative(this.config.getTargetDir(), p)),
+              {
+                respectGitIgnore: true,
+                respectGeminiIgnore: false,
+              },
+            )
+            .map((p) => path.resolve(this.config.getTargetDir(), p))
+        : entries;
+
+      // Apply gemini ignore filtering if enabled
+      const finalFilteredEntries = fileFilteringOptions.respectGeminiIgnore
+        ? fileDiscovery
+            .filterFiles(
+              gitFilteredEntries.map((p) =>
+                path.relative(this.config.getTargetDir(), p),
+              ),
+              {
+                respectGitIgnore: false,
+                respectGeminiIgnore: true,
+              },
+            )
+            .map((p) => path.resolve(this.config.getTargetDir(), p))
+        : gitFilteredEntries;
+
+      let gitIgnoredCount = 0;
+      let geminiIgnoredCount = 0;
+
+      for (const absoluteFilePath of entries) {
+        // Security check: ensure the glob library didn't return something outside the workspace.
+        if (
+          !this.config
+            .getWorkspaceContext()
+            .isPathWithinWorkspace(absoluteFilePath)
+        ) {
+          skippedFiles.push({
+            path: absoluteFilePath,
+            reason: `Security: Glob library returned path outside workspace. Path: ${absoluteFilePath}`,
+          });
+          continue;
+        }
+
+        // Check if this file was filtered out by git ignore
+        if (
+          fileFilteringOptions.respectGitIgnore &&
+          !gitFilteredEntries.includes(absoluteFilePath)
+        ) {
+          gitIgnoredCount++;
+          continue;
+        }
+
+        // Check if this file was filtered out by gemini ignore
+        if (
+          fileFilteringOptions.respectGeminiIgnore &&
+          !finalFilteredEntries.includes(absoluteFilePath)
+        ) {
+          geminiIgnoredCount++;
+          continue;
+        }
+
+        filesToConsider.add(absoluteFilePath);
+      }
+
+      // Add info about git-ignored files if any were filtered
+      if (gitIgnoredCount > 0) {
+        skippedFiles.push({
+          path: `${gitIgnoredCount} file(s)`,
+          reason: 'git ignored',
+        });
+      }
+
+      // Add info about gemini-ignored files if any were filtered
+      if (geminiIgnoredCount > 0) {
+        skippedFiles.push({
+          path: `${geminiIgnoredCount} file(s)`,
+          reason: 'gemini ignored',
+        });
+      }
+    } catch (error) {
+      return {
+        llmContent: `Error during file search: ${getErrorMessage(error)}`,
+        returnDisplay: `## File Search Error\n\nAn error occurred while searching for files:\n\`\`\`\n${getErrorMessage(error)}\n\`\`\``,
+      };
+    }
+
+    const sortedFiles = Array.from(filesToConsider).sort();
+
+    const fileProcessingPromises = sortedFiles.map(
+      async (filePath): Promise<FileProcessingResult> => {
+        try {
+          const relativePathForDisplay = path
+            .relative(this.config.getTargetDir(), filePath)
+            .replace(/\\/g, '/');
+
+          const fileType = await detectFileType(filePath);
+
+          if (fileType === 'image' || fileType === 'pdf') {
+            const fileExtension = path.extname(filePath).toLowerCase();
+            const fileNameWithoutExtension = path.basename(
+              filePath,
+              fileExtension,
+            );
+            const requestedExplicitly = inputPatterns.some(
+              (pattern: string) =>
+                pattern.toLowerCase().includes(fileExtension) ||
+                pattern.includes(fileNameWithoutExtension),
+            );
+
+            if (!requestedExplicitly) {
+              return {
+                success: false,
+                filePath,
+                relativePathForDisplay,
+                reason:
+                  'asset file (image/pdf) was not explicitly requested by name or extension',
+              };
+            }
+          }
+
+          // Use processSingleFileContent for all file types now
+          const fileReadResult = await processSingleFileContent(
+            filePath,
+            this.config.getTargetDir(),
+            this.config.getFileSystemService(),
+          );
+
+          if (fileReadResult.error) {
+            return {
+              success: false,
+              filePath,
+              relativePathForDisplay,
+              reason: `Read error: ${fileReadResult.error}`,
+            };
+          }
+
+          return {
+            success: true,
+            filePath,
+            relativePathForDisplay,
+            fileReadResult,
+          };
+        } catch (error) {
+          const relativePathForDisplay = path
+            .relative(this.config.getTargetDir(), filePath)
+            .replace(/\\/g, '/');
+
+          return {
+            success: false,
+            filePath,
+            relativePathForDisplay,
+            reason: `Unexpected error: ${error instanceof Error ? error.message : String(error)}`,
+          };
+        }
+      },
+    );
+
+    const results = await Promise.allSettled(fileProcessingPromises);
+
+    for (const result of results) {
+      if (result.status === 'fulfilled') {
+        const fileResult = result.value;
+
+        if (!fileResult.success) {
+          // Handle skipped files (images/PDFs not requested or read errors)
+          skippedFiles.push({
+            path: fileResult.relativePathForDisplay,
+            reason: fileResult.reason,
+          });
+        } else {
+          // Handle successfully processed files
+          const { filePath, relativePathForDisplay, fileReadResult } =
+            fileResult;
+
+          if (typeof fileReadResult.llmContent === 'string') {
+            const separator = DEFAULT_OUTPUT_SEPARATOR_FORMAT.replace(
+              '{filePath}',
+              filePath,
+            );
+            let fileContentForLlm = '';
+            if (fileReadResult.isTruncated) {
+              fileContentForLlm += `[WARNING: This file was truncated. To view the full content, use the 'read_file' tool on this specific file.]\n\n`;
+            }
+            fileContentForLlm += fileReadResult.llmContent;
+            contentParts.push(`${separator}\n\n${fileContentForLlm}\n\n`);
+          } else {
+            // This is a Part for image/pdf, which we don't add the separator to.
+            contentParts.push(fileReadResult.llmContent);
+          }
+
+          processedFilesRelativePaths.push(relativePathForDisplay);
+
+          const lines =
+            typeof fileReadResult.llmContent === 'string'
+              ? fileReadResult.llmContent.split('\n').length
+              : undefined;
+          const mimetype = getSpecificMimeType(filePath);
+          recordFileOperationMetric(
+            this.config,
+            FileOperation.READ,
+            lines,
+            mimetype,
+            path.extname(filePath),
+          );
+        }
+      } else {
+        // Handle Promise rejection (unexpected errors)
+        skippedFiles.push({
+          path: 'unknown',
+          reason: `Unexpected error: ${result.reason}`,
+        });
+      }
+    }
+
+    let displayMessage = `### ReadManyFiles Result (Target Dir: \`${this.config.getTargetDir()}\`)\n\n`;
+    if (processedFilesRelativePaths.length > 0) {
+      displayMessage += `Successfully read and concatenated content from **${processedFilesRelativePaths.length} file(s)**.\n`;
+      if (processedFilesRelativePaths.length <= 10) {
+        displayMessage += `\n**Processed Files:**\n`;
+        processedFilesRelativePaths.forEach(
+          (p) => (displayMessage += `- \`${p}\`\n`),
+        );
+      } else {
+        displayMessage += `\n**Processed Files (first 10 shown):**\n`;
+        processedFilesRelativePaths
+          .slice(0, 10)
+          .forEach((p) => (displayMessage += `- \`${p}\`\n`));
+        displayMessage += `- ...and ${processedFilesRelativePaths.length - 10} more.\n`;
+      }
+    }
+
+    if (skippedFiles.length > 0) {
+      if (processedFilesRelativePaths.length === 0) {
+        displayMessage += `No files were read and concatenated based on the criteria.\n`;
+      }
+      if (skippedFiles.length <= 5) {
+        displayMessage += `\n**Skipped ${skippedFiles.length} item(s):**\n`;
+      } else {
+        displayMessage += `\n**Skipped ${skippedFiles.length} item(s) (first 5 shown):**\n`;
+      }
+      skippedFiles
+        .slice(0, 5)
+        .forEach(
+          (f) => (displayMessage += `- \`${f.path}\` (Reason: ${f.reason})\n`),
+        );
+      if (skippedFiles.length > 5) {
+        displayMessage += `- ...and ${skippedFiles.length - 5} more.\n`;
+      }
+    } else if (
+      processedFilesRelativePaths.length === 0 &&
+      skippedFiles.length === 0
+    ) {
+      displayMessage += `No files were read and concatenated based on the criteria.\n`;
+    }
+
+    if (contentParts.length === 0) {
+      contentParts.push(
+        'No files matching the criteria were found or all were skipped.',
+      );
+    }
+    return {
+      llmContent: contentParts,
+      returnDisplay: displayMessage.trim(),
+    };
+  }
+}
+
+/**
+ * Tool implementation for finding and reading multiple text files from the local filesystem
+ * within a specified target directory. The content is concatenated.
+ * It is intended to run in an environment with access to the local file system (e.g., a Node.js backend).
+ */
+export class ReadManyFilesTool extends BaseDeclarativeTool<
+  ReadManyFilesParams,
+  ToolResult
+> {
+  static readonly Name: string = 'read_many_files';
+
+  constructor(private config: Config) {
+    const parameterSchema = {
+      type: 'object',
+      properties: {
+        paths: {
+          type: 'array',
+          items: {
+            type: 'string',
+            minLength: 1,
+          },
+          minItems: 1,
+          description:
+            "Required. An array of glob patterns or paths relative to the tool's target directory. Examples: ['src/**/*.ts'], ['README.md', 'docs/']",
+        },
+        include: {
+          type: 'array',
+          items: {
+            type: 'string',
+            minLength: 1,
+          },
+          description:
+            'Optional. Additional glob patterns to include. These are merged with `paths`. Example: "*.test.ts" to specifically add test files if they were broadly excluded.',
+          default: [],
+        },
+        exclude: {
+          type: 'array',
+          items: {
+            type: 'string',
+            minLength: 1,
+          },
+          description:
+            'Optional. Glob patterns for files/directories to exclude. Added to default excludes if useDefaultExcludes is true. Example: "**/*.log", "temp/"',
+          default: [],
+        },
+        recursive: {
+          type: 'boolean',
+          description:
+            'Optional. Whether to search recursively (primarily controlled by `**` in glob patterns). Defaults to true.',
+          default: true,
+        },
+        useDefaultExcludes: {
+          type: 'boolean',
+          description:
+            'Optional. Whether to apply a list of default exclusion patterns (e.g., node_modules, .git, binary files). Defaults to true.',
+          default: true,
+        },
+        file_filtering_options: {
+          description:
+            'Whether to respect ignore patterns from .gitignore or .geminiignore',
+          type: 'object',
+          properties: {
+            respect_git_ignore: {
+              description:
+                'Optional: Whether to respect .gitignore patterns when listing files. Only available in git repositories. Defaults to true.',
+              type: 'boolean',
+            },
+            respect_gemini_ignore: {
+              description:
+                'Optional: Whether to respect .geminiignore patterns when listing files. Defaults to true.',
+              type: 'boolean',
+            },
+          },
+        },
+      },
+      required: ['paths'],
+    };
+
+    super(
+      ReadManyFilesTool.Name,
+      'ReadManyFiles',
+      `Reads content from multiple files specified by paths or glob patterns within a configured target directory. For text files, it concatenates their content into a single string. It is primarily designed for text-based files. However, it can also process image (e.g., .png, .jpg) and PDF (.pdf) files if their file names or extensions are explicitly included in the 'paths' argument. For these explicitly requested non-text files, their data is read and included in a format suitable for model consumption (e.g., base64 encoded).
+
+This tool is useful when you need to understand or analyze a collection of files, such as:
+- Getting an overview of a codebase or parts of it (e.g., all TypeScript files in the 'src' directory).
+- Finding where specific functionality is implemented if the user asks broad questions about code.
+- Reviewing documentation files (e.g., all Markdown files in the 'docs' directory).
+- Gathering context from multiple configuration files.
+- When the user asks to "read all files in X directory" or "show me the content of all Y files".
+
+Use this tool when the user's query implies needing the content of several files simultaneously for context, analysis, or summarization. For text files, it uses default UTF-8 encoding and a '--- {filePath} ---' separator between file contents. Ensure paths are relative to the target directory. Glob patterns like 'src/**/*.js' are supported. Avoid using for single files if a more specific single-file reading tool is available, unless the user specifically requests to process a list containing just one file via this tool. Other binary files (not explicitly requested as image/PDF) are generally skipped. Default excludes apply to common non-text files (except for explicitly requested images/PDFs) and large dependency directories unless 'useDefaultExcludes' is false.`,
+      Kind.Read,
+      parameterSchema,
+    );
+  }
+
+  protected createInvocation(
+    params: ReadManyFilesParams,
+  ): ToolInvocation<ReadManyFilesParams, ToolResult> {
+    return new ReadManyFilesToolInvocation(this.config, params);
+  }
+}

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

@@ -0,0 +1,878 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import {
+  vi,
+  describe,
+  it,
+  expect,
+  beforeEach,
+  afterEach,
+  type Mock,
+} from 'vitest';
+
+const mockShellExecutionService = vi.hoisted(() => vi.fn());
+vi.mock('../services/shellExecutionService.js', () => ({
+  ShellExecutionService: { execute: mockShellExecutionService },
+}));
+vi.mock('fs');
+vi.mock('os');
+vi.mock('crypto');
+vi.mock('../utils/summarizer.js');
+
+import { isCommandAllowed } from '../utils/shell-utils.js';
+import { ShellTool } from './shell.js';
+import { type Config } from '../config/config.js';
+import {
+  type ShellExecutionResult,
+  type ShellOutputEvent,
+} from '../services/shellExecutionService.js';
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import * as crypto from 'crypto';
+import * as summarizer from '../utils/summarizer.js';
+import { ToolConfirmationOutcome } from './tools.js';
+import { OUTPUT_UPDATE_INTERVAL_MS } from './shell.js';
+import { createMockWorkspaceContext } from '../test-utils/mockWorkspaceContext.js';
+
+describe('ShellTool', () => {
+  let shellTool: ShellTool;
+  let mockConfig: Config;
+  let mockShellOutputCallback: (event: ShellOutputEvent) => void;
+  let resolveExecutionPromise: (result: ShellExecutionResult) => void;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+
+    mockConfig = {
+      getCoreTools: vi.fn().mockReturnValue([]),
+      getExcludeTools: vi.fn().mockReturnValue([]),
+      getDebugMode: vi.fn().mockReturnValue(false),
+      getTargetDir: vi.fn().mockReturnValue('/test/dir'),
+      getSummarizeToolOutputConfig: vi.fn().mockReturnValue(undefined),
+      getWorkspaceContext: () => createMockWorkspaceContext('.'),
+      getGeminiClient: vi.fn(),
+      getGitCoAuthor: vi.fn().mockReturnValue({
+        enabled: true,
+        name: 'Qwen-Coder',
+        email: 'qwen-coder@alibabacloud.com',
+      }),
+      getShouldUseNodePtyShell: vi.fn().mockReturnValue(false),
+    } as unknown as Config;
+
+    shellTool = new ShellTool(mockConfig);
+
+    vi.mocked(os.platform).mockReturnValue('linux');
+    vi.mocked(os.tmpdir).mockReturnValue('/tmp');
+    (vi.mocked(crypto.randomBytes) as Mock).mockReturnValue(
+      Buffer.from('abcdef', 'hex'),
+    );
+
+    // Capture the output callback to simulate streaming events from the service
+    mockShellExecutionService.mockImplementation((_cmd, _cwd, callback) => {
+      mockShellOutputCallback = callback;
+      return {
+        pid: 12345,
+        result: new Promise((resolve) => {
+          resolveExecutionPromise = resolve;
+        }),
+      };
+    });
+  });
+
+  describe('isCommandAllowed', () => {
+    it('should allow a command if no restrictions are provided', () => {
+      (mockConfig.getCoreTools as Mock).mockReturnValue(undefined);
+      (mockConfig.getExcludeTools as Mock).mockReturnValue(undefined);
+      expect(isCommandAllowed('ls -l', mockConfig).allowed).toBe(true);
+    });
+
+    it('should block a command with command substitution using $()', () => {
+      expect(isCommandAllowed('echo $(rm -rf /)', mockConfig).allowed).toBe(
+        false,
+      );
+    });
+  });
+
+  describe('build', () => {
+    it('should return an invocation for a valid command', () => {
+      const invocation = shellTool.build({
+        command: 'ls -l',
+        is_background: false,
+      });
+      expect(invocation).toBeDefined();
+    });
+
+    it('should throw an error for an empty command', () => {
+      expect(() =>
+        shellTool.build({ command: ' ', is_background: false }),
+      ).toThrow('Command cannot be empty.');
+    });
+
+    it('should throw an error for a non-existent directory', () => {
+      vi.mocked(fs.existsSync).mockReturnValue(false);
+      expect(() =>
+        shellTool.build({
+          command: 'ls',
+          directory: 'rel/path',
+          is_background: false,
+        }),
+      ).toThrow(
+        "Directory 'rel/path' is not a registered workspace directory.",
+      );
+    });
+
+    it('should include background indicator in description when is_background is true', () => {
+      const invocation = shellTool.build({
+        command: 'npm start',
+        is_background: true,
+      });
+      expect(invocation.getDescription()).toContain('[background]');
+    });
+
+    it('should not include background indicator in description when is_background is false', () => {
+      const invocation = shellTool.build({
+        command: 'npm test',
+        is_background: false,
+      });
+      expect(invocation.getDescription()).not.toContain('[background]');
+    });
+  });
+
+  describe('execute', () => {
+    const mockAbortSignal = new AbortController().signal;
+
+    const resolveShellExecution = (
+      result: Partial<ShellExecutionResult> = {},
+    ) => {
+      const fullResult: ShellExecutionResult = {
+        rawOutput: Buffer.from(result.output || ''),
+        output: 'Success',
+        exitCode: 0,
+        signal: null,
+        error: null,
+        aborted: false,
+        pid: 12345,
+        executionMethod: 'child_process',
+        ...result,
+      };
+      resolveExecutionPromise(fullResult);
+    };
+
+    it('should wrap command on linux and parse pgrep output', async () => {
+      const invocation = shellTool.build({
+        command: 'my-command &',
+        is_background: false,
+      });
+      const promise = invocation.execute(mockAbortSignal);
+      resolveShellExecution({ pid: 54321 });
+
+      vi.mocked(fs.existsSync).mockReturnValue(true);
+      vi.mocked(fs.readFileSync).mockReturnValue('54321\n54322\n'); // Service PID and background PID
+
+      const result = await promise;
+
+      const tmpFile = path.join(os.tmpdir(), 'shell_pgrep_abcdef.tmp');
+      const wrappedCommand = `{ my-command & }; __code=$?; pgrep -g 0 >${tmpFile} 2>&1; exit $__code;`;
+      expect(mockShellExecutionService).toHaveBeenCalledWith(
+        wrappedCommand,
+        expect.any(String),
+        expect.any(Function),
+        mockAbortSignal,
+        false,
+        undefined,
+        undefined,
+      );
+      expect(result.llmContent).toContain('Background PIDs: 54322');
+      expect(vi.mocked(fs.unlinkSync)).toHaveBeenCalledWith(tmpFile);
+    });
+
+    it('should add ampersand to command when is_background is true and command does not end with &', async () => {
+      const invocation = shellTool.build({
+        command: 'npm start',
+        is_background: true,
+      });
+      const promise = invocation.execute(mockAbortSignal);
+      resolveShellExecution({ pid: 54321 });
+
+      vi.mocked(fs.existsSync).mockReturnValue(true);
+      vi.mocked(fs.readFileSync).mockReturnValue('54321\n54322\n');
+
+      await promise;
+
+      const tmpFile = path.join(os.tmpdir(), 'shell_pgrep_abcdef.tmp');
+      const wrappedCommand = `{ npm start & }; __code=$?; pgrep -g 0 >${tmpFile} 2>&1; exit $__code;`;
+      expect(mockShellExecutionService).toHaveBeenCalledWith(
+        wrappedCommand,
+        expect.any(String),
+        expect.any(Function),
+        mockAbortSignal,
+        false,
+        undefined,
+        undefined,
+      );
+    });
+
+    it('should not add extra ampersand when is_background is true and command already ends with &', async () => {
+      const invocation = shellTool.build({
+        command: 'npm start &',
+        is_background: true,
+      });
+      const promise = invocation.execute(mockAbortSignal);
+      resolveShellExecution({ pid: 54321 });
+
+      vi.mocked(fs.existsSync).mockReturnValue(true);
+      vi.mocked(fs.readFileSync).mockReturnValue('54321\n54322\n');
+
+      await promise;
+
+      const tmpFile = path.join(os.tmpdir(), 'shell_pgrep_abcdef.tmp');
+      const wrappedCommand = `{ npm start & }; __code=$?; pgrep -g 0 >${tmpFile} 2>&1; exit $__code;`;
+      expect(mockShellExecutionService).toHaveBeenCalledWith(
+        wrappedCommand,
+        expect.any(String),
+        expect.any(Function),
+        mockAbortSignal,
+        false,
+        undefined,
+        undefined,
+      );
+    });
+
+    it('should not add ampersand when is_background is false', async () => {
+      const invocation = shellTool.build({
+        command: 'npm test',
+        is_background: false,
+      });
+      const promise = invocation.execute(mockAbortSignal);
+      resolveShellExecution({ pid: 54321 });
+
+      vi.mocked(fs.existsSync).mockReturnValue(true);
+      vi.mocked(fs.readFileSync).mockReturnValue('54321\n54322\n');
+
+      await promise;
+
+      const tmpFile = path.join(os.tmpdir(), 'shell_pgrep_abcdef.tmp');
+      const wrappedCommand = `{ npm test; }; __code=$?; pgrep -g 0 >${tmpFile} 2>&1; exit $__code;`;
+      expect(mockShellExecutionService).toHaveBeenCalledWith(
+        wrappedCommand,
+        expect.any(String),
+        expect.any(Function),
+        mockAbortSignal,
+        false,
+        undefined,
+        undefined,
+      );
+    });
+
+    it('should not wrap command on windows', async () => {
+      vi.mocked(os.platform).mockReturnValue('win32');
+      const invocation = shellTool.build({
+        command: 'dir',
+        is_background: false,
+      });
+      const promise = invocation.execute(mockAbortSignal);
+      resolveShellExecution({
+        rawOutput: Buffer.from(''),
+        output: '',
+        exitCode: 0,
+        signal: null,
+        error: null,
+        aborted: false,
+        pid: 12345,
+        executionMethod: 'child_process',
+      });
+      await promise;
+      expect(mockShellExecutionService).toHaveBeenCalledWith(
+        'dir',
+        expect.any(String),
+        expect.any(Function),
+        mockAbortSignal,
+        false,
+        undefined,
+        undefined,
+      );
+    });
+
+    it('should format error messages correctly', async () => {
+      const error = new Error('wrapped command failed');
+      const invocation = shellTool.build({
+        command: 'user-command',
+        is_background: false,
+      });
+      const promise = invocation.execute(mockAbortSignal);
+      resolveShellExecution({
+        error,
+        exitCode: 1,
+        output: 'err',
+        rawOutput: Buffer.from('err'),
+        signal: null,
+        aborted: false,
+        pid: 12345,
+        executionMethod: 'child_process',
+      });
+
+      const result = await promise;
+      expect(result.llmContent).toContain('Error: wrapped command failed');
+      expect(result.llmContent).not.toContain('pgrep');
+    });
+
+    it('should throw an error for invalid parameters', () => {
+      expect(() =>
+        shellTool.build({ command: '', is_background: false }),
+      ).toThrow('Command cannot be empty.');
+    });
+
+    it('should throw an error for invalid directory', () => {
+      vi.mocked(fs.existsSync).mockReturnValue(false);
+      expect(() =>
+        shellTool.build({
+          command: 'ls',
+          directory: 'nonexistent',
+          is_background: false,
+        }),
+      ).toThrow(
+        `Directory 'nonexistent' is not a registered workspace directory.`,
+      );
+    });
+
+    it('should summarize output when configured', async () => {
+      (mockConfig.getSummarizeToolOutputConfig as Mock).mockReturnValue({
+        [shellTool.name]: { tokenBudget: 1000 },
+      });
+      vi.mocked(summarizer.summarizeToolOutput).mockResolvedValue(
+        'summarized output',
+      );
+
+      const invocation = shellTool.build({
+        command: 'ls',
+        is_background: false,
+      });
+      const promise = invocation.execute(mockAbortSignal);
+      resolveExecutionPromise({
+        output: 'long output',
+        rawOutput: Buffer.from('long output'),
+        exitCode: 0,
+        signal: null,
+        error: null,
+        aborted: false,
+        pid: 12345,
+        executionMethod: 'child_process',
+      });
+
+      const result = await promise;
+
+      expect(summarizer.summarizeToolOutput).toHaveBeenCalledWith(
+        expect.any(String),
+        mockConfig.getGeminiClient(),
+        mockAbortSignal,
+        1000,
+      );
+      expect(result.llmContent).toBe('summarized output');
+      expect(result.returnDisplay).toBe('long output');
+    });
+
+    it('should clean up the temp file on synchronous execution error', async () => {
+      const error = new Error('sync spawn error');
+      mockShellExecutionService.mockImplementation(() => {
+        throw error;
+      });
+      vi.mocked(fs.existsSync).mockReturnValue(true); // Pretend the file exists
+
+      const invocation = shellTool.build({
+        command: 'a-command',
+        is_background: false,
+      });
+      await expect(invocation.execute(mockAbortSignal)).rejects.toThrow(error);
+
+      const tmpFile = path.join(os.tmpdir(), 'shell_pgrep_abcdef.tmp');
+      expect(vi.mocked(fs.unlinkSync)).toHaveBeenCalledWith(tmpFile);
+    });
+
+    describe('Streaming to `updateOutput`', () => {
+      let updateOutputMock: Mock;
+      beforeEach(() => {
+        vi.useFakeTimers({ toFake: ['Date'] });
+        updateOutputMock = vi.fn();
+      });
+      afterEach(() => {
+        vi.useRealTimers();
+      });
+
+      it('should throttle text output updates', async () => {
+        const invocation = shellTool.build({
+          command: 'stream',
+          is_background: false,
+        });
+        const promise = invocation.execute(mockAbortSignal, updateOutputMock);
+
+        // First chunk, should be throttled.
+        mockShellOutputCallback({
+          type: 'data',
+          chunk: 'hello ',
+        });
+        expect(updateOutputMock).not.toHaveBeenCalled();
+
+        // Advance time past the throttle interval.
+        await vi.advanceTimersByTimeAsync(OUTPUT_UPDATE_INTERVAL_MS + 1);
+
+        // Send a second chunk. THIS event triggers the update with the CUMULATIVE content.
+        mockShellOutputCallback({
+          type: 'data',
+          chunk: 'hello world',
+        });
+
+        // It should have been called once now with the combined output.
+        expect(updateOutputMock).toHaveBeenCalledOnce();
+        expect(updateOutputMock).toHaveBeenCalledWith('hello world');
+
+        resolveExecutionPromise({
+          rawOutput: Buffer.from(''),
+          output: '',
+          exitCode: 0,
+          signal: null,
+          error: null,
+          aborted: false,
+          pid: 12345,
+          executionMethod: 'child_process',
+        });
+        await promise;
+      });
+
+      it('should immediately show binary detection message and throttle progress', async () => {
+        const invocation = shellTool.build({
+          command: 'cat img',
+          is_background: false,
+        });
+        const promise = invocation.execute(mockAbortSignal, updateOutputMock);
+
+        mockShellOutputCallback({ type: 'binary_detected' });
+        expect(updateOutputMock).toHaveBeenCalledOnce();
+        expect(updateOutputMock).toHaveBeenCalledWith(
+          '[Binary output detected. Halting stream...]',
+        );
+
+        mockShellOutputCallback({
+          type: 'binary_progress',
+          bytesReceived: 1024,
+        });
+        expect(updateOutputMock).toHaveBeenCalledOnce();
+
+        // Advance time past the throttle interval.
+        await vi.advanceTimersByTimeAsync(OUTPUT_UPDATE_INTERVAL_MS + 1);
+
+        // Send a SECOND progress event. This one will trigger the flush.
+        mockShellOutputCallback({
+          type: 'binary_progress',
+          bytesReceived: 2048,
+        });
+
+        // Now it should be called a second time with the latest progress.
+        expect(updateOutputMock).toHaveBeenCalledTimes(2);
+        expect(updateOutputMock).toHaveBeenLastCalledWith(
+          '[Receiving binary output... 2.0 KB received]',
+        );
+
+        resolveExecutionPromise({
+          rawOutput: Buffer.from(''),
+          output: '',
+          exitCode: 0,
+          signal: null,
+          error: null,
+          aborted: false,
+          pid: 12345,
+          executionMethod: 'child_process',
+        });
+        await promise;
+      });
+    });
+
+    describe('addCoAuthorToGitCommit', () => {
+      it('should add co-author to git commit with double quotes', async () => {
+        const command = 'git commit -m "Initial commit"';
+        const invocation = shellTool.build({ command, is_background: false });
+        const promise = invocation.execute(mockAbortSignal);
+
+        // Mock the shell execution to return success
+        resolveExecutionPromise({
+          rawOutput: Buffer.from(''),
+          output: '',
+          exitCode: 0,
+          signal: null,
+          error: null,
+          aborted: false,
+          pid: 12345,
+          executionMethod: 'child_process',
+        });
+
+        await promise;
+
+        // Verify that the command was executed with co-author added
+        expect(mockShellExecutionService).toHaveBeenCalledWith(
+          expect.stringContaining(
+            'Co-authored-by: Qwen-Coder <qwen-coder@alibabacloud.com>',
+          ),
+          expect.any(String),
+          expect.any(Function),
+          mockAbortSignal,
+          false,
+          undefined,
+          undefined,
+        );
+      });
+
+      it('should add co-author to git commit with single quotes', async () => {
+        const command = "git commit -m 'Fix bug'";
+        const invocation = shellTool.build({ command, is_background: false });
+        const promise = invocation.execute(mockAbortSignal);
+
+        resolveExecutionPromise({
+          rawOutput: Buffer.from(''),
+          output: '',
+          exitCode: 0,
+          signal: null,
+          error: null,
+          aborted: false,
+          pid: 12345,
+          executionMethod: 'child_process',
+        });
+
+        await promise;
+
+        expect(mockShellExecutionService).toHaveBeenCalledWith(
+          expect.stringContaining(
+            'Co-authored-by: Qwen-Coder <qwen-coder@alibabacloud.com>',
+          ),
+          expect.any(String),
+          expect.any(Function),
+          mockAbortSignal,
+          false,
+          undefined,
+          undefined,
+        );
+      });
+
+      it('should handle git commit with additional flags', async () => {
+        const command = 'git commit -a -m "Add feature"';
+        const invocation = shellTool.build({ command, is_background: false });
+        const promise = invocation.execute(mockAbortSignal);
+
+        resolveExecutionPromise({
+          rawOutput: Buffer.from(''),
+          output: '',
+          exitCode: 0,
+          signal: null,
+          error: null,
+          aborted: false,
+          pid: 12345,
+          executionMethod: 'child_process',
+        });
+
+        await promise;
+
+        expect(mockShellExecutionService).toHaveBeenCalledWith(
+          expect.stringContaining(
+            'Co-authored-by: Qwen-Coder <qwen-coder@alibabacloud.com>',
+          ),
+          expect.any(String),
+          expect.any(Function),
+          mockAbortSignal,
+          false,
+          undefined,
+          undefined,
+        );
+      });
+
+      it('should not modify non-git commands', async () => {
+        const command = 'npm install';
+        const invocation = shellTool.build({ command, is_background: false });
+        const promise = invocation.execute(mockAbortSignal);
+
+        resolveExecutionPromise({
+          rawOutput: Buffer.from(''),
+          output: '',
+          exitCode: 0,
+          signal: null,
+          error: null,
+          aborted: false,
+          pid: 12345,
+          executionMethod: 'child_process',
+        });
+
+        await promise;
+
+        // On Linux, commands are wrapped with pgrep functionality
+        expect(mockShellExecutionService).toHaveBeenCalledWith(
+          expect.stringContaining('npm install'),
+          expect.any(String),
+          expect.any(Function),
+          mockAbortSignal,
+          false,
+          undefined,
+          undefined,
+        );
+      });
+
+      it('should not modify git commands without -m flag', async () => {
+        const command = 'git commit';
+        const invocation = shellTool.build({ command, is_background: false });
+        const promise = invocation.execute(mockAbortSignal);
+
+        resolveExecutionPromise({
+          rawOutput: Buffer.from(''),
+          output: '',
+          exitCode: 0,
+          signal: null,
+          error: null,
+          aborted: false,
+          pid: 12345,
+          executionMethod: 'child_process',
+        });
+
+        await promise;
+
+        // On Linux, commands are wrapped with pgrep functionality
+        expect(mockShellExecutionService).toHaveBeenCalledWith(
+          expect.stringContaining('git commit'),
+          expect.any(String),
+          expect.any(Function),
+          mockAbortSignal,
+          false,
+          undefined,
+          undefined,
+        );
+      });
+
+      it('should handle git commit with escaped quotes in message', async () => {
+        const command = 'git commit -m "Fix \\"quoted\\" text"';
+        const invocation = shellTool.build({ command, is_background: false });
+        const promise = invocation.execute(mockAbortSignal);
+
+        resolveExecutionPromise({
+          rawOutput: Buffer.from(''),
+          output: '',
+          exitCode: 0,
+          signal: null,
+          error: null,
+          aborted: false,
+          pid: 12345,
+          executionMethod: 'child_process',
+        });
+
+        await promise;
+
+        expect(mockShellExecutionService).toHaveBeenCalledWith(
+          expect.stringContaining(
+            'Co-authored-by: Qwen-Coder <qwen-coder@alibabacloud.com>',
+          ),
+          expect.any(String),
+          expect.any(Function),
+          mockAbortSignal,
+          false,
+          undefined,
+          undefined,
+        );
+      });
+
+      it('should not add co-author when disabled in config', async () => {
+        // Mock config with disabled co-author
+        (mockConfig.getGitCoAuthor as Mock).mockReturnValue({
+          enabled: false,
+          name: 'Qwen-Coder',
+          email: 'qwen-coder@alibabacloud.com',
+        });
+
+        const command = 'git commit -m "Initial commit"';
+        const invocation = shellTool.build({ command, is_background: false });
+        const promise = invocation.execute(mockAbortSignal);
+
+        resolveExecutionPromise({
+          rawOutput: Buffer.from(''),
+          output: '',
+          exitCode: 0,
+          signal: null,
+          error: null,
+          aborted: false,
+          pid: 12345,
+          executionMethod: 'child_process',
+        });
+
+        await promise;
+
+        // On Linux, commands are wrapped with pgrep functionality
+        expect(mockShellExecutionService).toHaveBeenCalledWith(
+          expect.stringContaining('git commit -m "Initial commit"'),
+          expect.any(String),
+          expect.any(Function),
+          mockAbortSignal,
+          false,
+          undefined,
+          undefined,
+        );
+      });
+
+      it('should use custom name and email from config', async () => {
+        // Mock config with custom co-author details
+        (mockConfig.getGitCoAuthor as Mock).mockReturnValue({
+          enabled: true,
+          name: 'Custom Bot',
+          email: 'custom@example.com',
+        });
+
+        const command = 'git commit -m "Test commit"';
+        const invocation = shellTool.build({ command, is_background: false });
+        const promise = invocation.execute(mockAbortSignal);
+
+        resolveExecutionPromise({
+          rawOutput: Buffer.from(''),
+          output: '',
+          exitCode: 0,
+          signal: null,
+          error: null,
+          aborted: false,
+          pid: 12345,
+          executionMethod: 'child_process',
+        });
+
+        await promise;
+
+        expect(mockShellExecutionService).toHaveBeenCalledWith(
+          expect.stringContaining(
+            'Co-authored-by: Custom Bot <custom@example.com>',
+          ),
+          expect.any(String),
+          expect.any(Function),
+          mockAbortSignal,
+          false,
+          undefined,
+          undefined,
+        );
+      });
+    });
+  });
+
+  describe('shouldConfirmExecute', () => {
+    it('should request confirmation for a new command and whitelist it on "Always"', async () => {
+      const params = { command: 'npm install', is_background: false };
+      const invocation = shellTool.build(params);
+      const confirmation = await invocation.shouldConfirmExecute(
+        new AbortController().signal,
+      );
+
+      expect(confirmation).not.toBe(false);
+      expect(confirmation && confirmation.type).toBe('exec');
+
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      await (confirmation as any).onConfirm(
+        ToolConfirmationOutcome.ProceedAlways,
+      );
+
+      // Should now be whitelisted
+      const secondInvocation = shellTool.build({
+        command: 'npm test',
+        is_background: false,
+      });
+      const secondConfirmation = await secondInvocation.shouldConfirmExecute(
+        new AbortController().signal,
+      );
+      expect(secondConfirmation).toBe(false);
+    });
+
+    it('should throw an error if validation fails', () => {
+      expect(() =>
+        shellTool.build({ command: '', is_background: false }),
+      ).toThrow();
+    });
+  });
+
+  describe('getDescription', () => {
+    it('should return the windows description when on windows', () => {
+      vi.mocked(os.platform).mockReturnValue('win32');
+      const shellTool = new ShellTool(mockConfig);
+      expect(shellTool.description).toMatchSnapshot();
+    });
+
+    it('should return the non-windows description when not on windows', () => {
+      vi.mocked(os.platform).mockReturnValue('linux');
+      const shellTool = new ShellTool(mockConfig);
+      expect(shellTool.description).toMatchSnapshot();
+    });
+  });
+});
+
+describe('validateToolParams', () => {
+  it('should return null for valid directory', () => {
+    const config = {
+      getCoreTools: () => undefined,
+      getExcludeTools: () => undefined,
+      getTargetDir: () => '/root',
+      getWorkspaceContext: () =>
+        createMockWorkspaceContext('/root', ['/users/test']),
+    } as unknown as Config;
+    const shellTool = new ShellTool(config);
+    const result = shellTool.validateToolParams({
+      command: 'ls',
+      directory: 'test',
+      is_background: false,
+    });
+    expect(result).toBeNull();
+  });
+
+  it('should return error for directory outside workspace', () => {
+    const config = {
+      getCoreTools: () => undefined,
+      getExcludeTools: () => undefined,
+      getTargetDir: () => '/root',
+      getWorkspaceContext: () =>
+        createMockWorkspaceContext('/root', ['/users/test']),
+    } as unknown as Config;
+    const shellTool = new ShellTool(config);
+    const result = shellTool.validateToolParams({
+      command: 'ls',
+      directory: 'test2',
+      is_background: false,
+    });
+    expect(result).toContain('is not a registered workspace directory');
+  });
+});
+
+describe('build', () => {
+  it('should return an invocation for valid directory', () => {
+    const config = {
+      getCoreTools: () => undefined,
+      getExcludeTools: () => undefined,
+      getTargetDir: () => '/root',
+      getWorkspaceContext: () =>
+        createMockWorkspaceContext('/root', ['/users/test']),
+    } as unknown as Config;
+    const shellTool = new ShellTool(config);
+    const invocation = shellTool.build({
+      command: 'ls',
+      directory: 'test',
+      is_background: false,
+    });
+    expect(invocation).toBeDefined();
+  });
+
+  it('should throw an error for directory outside workspace', () => {
+    const config = {
+      getCoreTools: () => undefined,
+      getExcludeTools: () => undefined,
+      getTargetDir: () => '/root',
+      getWorkspaceContext: () =>
+        createMockWorkspaceContext('/root', ['/users/test']),
+    } as unknown as Config;
+    const shellTool = new ShellTool(config);
+    expect(() =>
+      shellTool.build({
+        command: 'ls',
+        directory: 'test2',
+        is_background: false,
+      }),
+    ).toThrow('is not a registered workspace directory');
+  });
+});