From 390edb5e0a9fa61b0bfccb48e543a18ce028c873 Mon Sep 17 00:00:00 2001
From: Sandy Tao <sandytao520@icloud.com>
Date: Tue, 5 Aug 2025 18:10:29 -0700
Subject: [PATCH 001/107] Add tests for useAtCompletion reset logic (#5639)

---
 .../cli/src/ui/hooks/useAtCompletion.test.ts  | 55 +++++++++++++++++++
 1 file changed, 55 insertions(+)

diff --git a/packages/cli/src/ui/hooks/useAtCompletion.test.ts b/packages/cli/src/ui/hooks/useAtCompletion.test.ts
index bf2453f5..58602d99 100644
--- a/packages/cli/src/ui/hooks/useAtCompletion.test.ts
+++ b/packages/cli/src/ui/hooks/useAtCompletion.test.ts
@@ -283,6 +283,61 @@ describe('useAtCompletion', () => {
     });
   });
 
+  describe('State Management', () => {
+    it('should reset the state when disabled after being in a READY state', async () => {
+      const structure: FileSystemStructure = { 'a.txt': '' };
+      testRootDir = await createTmpDir(structure);
+
+      const { result, rerender } = renderHook(
+        ({ enabled }) =>
+          useTestHarnessForAtCompletion(enabled, 'a', mockConfig, testRootDir),
+        { initialProps: { enabled: true } },
+      );
+
+      // Wait for the hook to be ready and have suggestions
+      await waitFor(() => {
+        expect(result.current.suggestions.map((s) => s.value)).toEqual([
+          'a.txt',
+        ]);
+      });
+
+      // Now, disable the hook
+      rerender({ enabled: false });
+
+      // The suggestions should be cleared immediately because of the RESET action
+      expect(result.current.suggestions).toEqual([]);
+    });
+
+    it('should reset the state when disabled after being in an ERROR state', async () => {
+      testRootDir = await createTmpDir({});
+
+      // Force an error during initialization
+      vi.spyOn(FileSearch.prototype, 'initialize').mockRejectedValueOnce(
+        new Error('Initialization failed'),
+      );
+
+      const { result, rerender } = renderHook(
+        ({ enabled }) =>
+          useTestHarnessForAtCompletion(enabled, '', mockConfig, testRootDir),
+        { initialProps: { enabled: true } },
+      );
+
+      // Wait for the hook to enter the error state
+      await waitFor(() => {
+        expect(result.current.isLoadingSuggestions).toBe(false);
+      });
+      expect(result.current.suggestions).toEqual([]); // No suggestions on error
+
+      // Now, disable the hook
+      rerender({ enabled: false });
+
+      // The state should still be reset (though visually it's the same)
+      // We can't directly inspect the internal state, but we can ensure it doesn't crash
+      // and the suggestions remain empty.
+      expect(result.current.suggestions).toEqual([]);
+    });
+  });
+
   describe('Filtering and Configuration', () => {
     it('should respect .gitignore files', async () => {
       const gitignoreContent = ['dist/', '*.log'].join('\n');

From 9db5aab4987ad64317a2f6724880265f8124250d Mon Sep 17 00:00:00 2001
From: christine betts <chrstn@uw.edu>
Date: Wed, 6 Aug 2025 01:13:22 +0000
Subject: [PATCH 002/107] Update a couple more witty phrases (#5641)

---
 packages/cli/src/ui/hooks/usePhraseCycler.ts | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/packages/cli/src/ui/hooks/usePhraseCycler.ts b/packages/cli/src/ui/hooks/usePhraseCycler.ts
index e87b4a03..73c8ccf0 100644
--- a/packages/cli/src/ui/hooks/usePhraseCycler.ts
+++ b/packages/cli/src/ui/hooks/usePhraseCycler.ts
@@ -43,7 +43,6 @@ export const WITTY_LOADING_PHRASES = [
   'Garbage collecting... be right back...',
   'Assembling the interwebs...',
   'Converting coffee into code...',
-  'Pushing to production (and hoping for the best)...',
   'Updating the syntax for reality...',
   'Rewiring the synapses...',
   'Looking for a misplaced semicolon...',
@@ -99,7 +98,7 @@ export const WITTY_LOADING_PHRASES = [
   'Why did the computer go to therapy? It had too many bytes...',
   "Why don't programmers like nature? It has too many bugs...",
   'Why do programmers prefer dark mode? Because light attracts bugs...',
-  'Why did the developer go broke? Because he used up all his cache...',
+  'Why did the developer go broke? Because they used up all their cache...',
   "What can you do with a broken pencil? Nothing, it's pointless...",
   'Applying percussive maintenance...',
   'Searching for the correct USB orientation...',

From 7e5a5e2da79783554dc4e3f00787317db29a589a Mon Sep 17 00:00:00 2001
From: Jacob MacDonald <jakemac@google.com>
Date: Tue, 5 Aug 2025 18:48:00 -0700
Subject: [PATCH 003/107] Detect and warn about cyclic tool refs when schema
 depth errors are encountered (#5609)

Co-authored-by: Jacob Richman <jacob314@gmail.com>
---
 packages/core/src/core/geminiChat.ts  |  39 ++++++++
 packages/core/src/tools/tools.test.ts | 125 ++++++++++++++++++++++++++
 packages/core/src/tools/tools.ts      |  85 ++++++++++++++++++
 3 files changed, 249 insertions(+)
 create mode 100644 packages/core/src/tools/tools.test.ts

diff --git a/packages/core/src/core/geminiChat.ts b/packages/core/src/core/geminiChat.ts
index bd81400f..c0e41b5e 100644
--- a/packages/core/src/core/geminiChat.ts
+++ b/packages/core/src/core/geminiChat.ts
@@ -32,6 +32,8 @@ import {
   ApiResponseEvent,
 } from '../telemetry/types.js';
 import { DEFAULT_GEMINI_FLASH_MODEL } from '../config/models.js';
+import { hasCycleInSchema } from '../tools/tools.js';
+import { isStructuredError } from '../utils/quotaErrorDetection.js';
 
 /**
  * Returns true if the response is valid, false otherwise.
@@ -299,6 +301,10 @@ export class GeminiChat {
 
       response = await retryWithBackoff(apiCall, {
         shouldRetry: (error: Error) => {
+          // Check for likely cyclic schema errors, don't retry those.
+          if (error.message.includes('maximum schema depth exceeded'))
+            return false;
+          // Check error messages for status codes, or specific error names if known
           if (error && error.message) {
             if (error.message.includes('429')) return true;
             if (error.message.match(/5\d{2}/)) return true;
@@ -345,6 +351,7 @@ export class GeminiChat {
     } catch (error) {
       const durationMs = Date.now() - startTime;
       this._logApiError(durationMs, error, prompt_id);
+      await this.maybeIncludeSchemaDepthContext(error);
       this.sendPromise = Promise.resolve();
       throw error;
     }
@@ -413,6 +420,9 @@ export class GeminiChat {
       // If errors occur mid-stream, this setup won't resume the stream; it will restart it.
       const streamResponse = await retryWithBackoff(apiCall, {
         shouldRetry: (error: Error) => {
+          // Check for likely cyclic schema errors, don't retry those.
+          if (error.message.includes('maximum schema depth exceeded'))
+            return false;
           // Check error messages for status codes, or specific error names if known
           if (error && error.message) {
             if (error.message.includes('429')) return true;
@@ -443,6 +453,7 @@ export class GeminiChat {
       const durationMs = Date.now() - startTime;
       this._logApiError(durationMs, error, prompt_id);
       this.sendPromise = Promise.resolve();
+      await this.maybeIncludeSchemaDepthContext(error);
       throw error;
     }
   }
@@ -674,4 +685,32 @@ export class GeminiChat {
       content.parts[0].thought === true
     );
   }
+
+  private async maybeIncludeSchemaDepthContext(error: unknown): Promise<void> {
+    // Check for potentially problematic cyclic tools with cyclic schemas
+    // and include a recommendation to remove potentially problematic tools.
+    if (
+      isStructuredError(error) &&
+      error.message.includes('maximum schema depth exceeded')
+    ) {
+      const tools = (await this.config.getToolRegistry()).getAllTools();
+      const cyclicSchemaTools: string[] = [];
+      for (const tool of tools) {
+        if (
+          (tool.schema.parametersJsonSchema &&
+            hasCycleInSchema(tool.schema.parametersJsonSchema)) ||
+          (tool.schema.parameters && hasCycleInSchema(tool.schema.parameters))
+        ) {
+          cyclicSchemaTools.push(tool.displayName);
+        }
+      }
+      if (cyclicSchemaTools.length > 0) {
+        const extraDetails =
+          `\n\nThis error was probably caused by cyclic schema references in one of the following tools, try disabling them:\n\n - ` +
+          cyclicSchemaTools.join(`\n - `) +
+          `\n`;
+        error.message += extraDetails;
+      }
+    }
+  }
 }
diff --git a/packages/core/src/tools/tools.test.ts b/packages/core/src/tools/tools.test.ts
new file mode 100644
index 00000000..9942d3a9
--- /dev/null
+++ b/packages/core/src/tools/tools.test.ts
@@ -0,0 +1,125 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { describe, it, expect } from 'vitest';
+import { hasCycleInSchema } from './tools.js'; // Added getStringifiedResultForDisplay
+
+describe('hasCycleInSchema', () => {
+  it('should detect a simple direct cycle', () => {
+    const schema = {
+      properties: {
+        data: {
+          $ref: '#/properties/data',
+        },
+      },
+    };
+    expect(hasCycleInSchema(schema)).toBe(true);
+  });
+
+  it('should detect a cycle from object properties referencing parent properties', () => {
+    const schema = {
+      type: 'object',
+      properties: {
+        data: {
+          type: 'object',
+          properties: {
+            child: { $ref: '#/properties/data' },
+          },
+        },
+      },
+    };
+    expect(hasCycleInSchema(schema)).toBe(true);
+  });
+
+  it('should detect a cycle from array items referencing parent properties', () => {
+    const schema = {
+      type: 'object',
+      properties: {
+        data: {
+          type: 'array',
+          items: {
+            type: 'object',
+            properties: {
+              child: { $ref: '#/properties/data/items' },
+            },
+          },
+        },
+      },
+    };
+    expect(hasCycleInSchema(schema)).toBe(true);
+  });
+
+  it('should detect a cycle between sibling properties', () => {
+    const schema = {
+      type: 'object',
+      properties: {
+        a: {
+          type: 'object',
+          properties: {
+            child: { $ref: '#/properties/b' },
+          },
+        },
+        b: {
+          type: 'object',
+          properties: {
+            child: { $ref: '#/properties/a' },
+          },
+        },
+      },
+    };
+    expect(hasCycleInSchema(schema)).toBe(true);
+  });
+
+  it('should not detect a cycle in a valid schema', () => {
+    const schema = {
+      type: 'object',
+      properties: {
+        name: { type: 'string' },
+        address: { $ref: '#/definitions/address' },
+      },
+      definitions: {
+        address: {
+          type: 'object',
+          properties: {
+            street: { type: 'string' },
+            city: { type: 'string' },
+          },
+        },
+      },
+    };
+    expect(hasCycleInSchema(schema)).toBe(false);
+  });
+
+  it('should handle non-cyclic sibling refs', () => {
+    const schema = {
+      properties: {
+        a: { $ref: '#/definitions/stringDef' },
+        b: { $ref: '#/definitions/stringDef' },
+      },
+      definitions: {
+        stringDef: { type: 'string' },
+      },
+    };
+    expect(hasCycleInSchema(schema)).toBe(false);
+  });
+
+  it('should handle nested but not cyclic refs', () => {
+    const schema = {
+      properties: {
+        a: { $ref: '#/definitions/defA' },
+      },
+      definitions: {
+        defA: { properties: { b: { $ref: '#/definitions/defB' } } },
+        defB: { type: 'string' },
+      },
+    };
+    expect(hasCycleInSchema(schema)).toBe(false);
+  });
+
+  it('should return false for an empty schema', () => {
+    expect(hasCycleInSchema({})).toBe(false);
+  });
+});
diff --git a/packages/core/src/tools/tools.ts b/packages/core/src/tools/tools.ts
index 0e3ffabf..5d9d9253 100644
--- a/packages/core/src/tools/tools.ts
+++ b/packages/core/src/tools/tools.ts
@@ -228,6 +228,91 @@ export interface ToolResult {
   };
 }
 
+/**
+ * Detects cycles in a JSON schemas due to `$ref`s.
+ * @param schema The root of the JSON schema.
+ * @returns `true` if a cycle is detected, `false` otherwise.
+ */
+export function hasCycleInSchema(schema: object): boolean {
+  function resolveRef(ref: string): object | null {
+    if (!ref.startsWith('#/')) {
+      return null;
+    }
+    const path = ref.substring(2).split('/');
+    let current: unknown = schema;
+    for (const segment of path) {
+      if (
+        typeof current !== 'object' ||
+        current === null ||
+        !Object.prototype.hasOwnProperty.call(current, segment)
+      ) {
+        return null;
+      }
+      current = (current as Record<string, unknown>)[segment];
+    }
+    return current as object;
+  }
+
+  function traverse(
+    node: unknown,
+    visitedRefs: Set<string>,
+    pathRefs: Set<string>,
+  ): boolean {
+    if (typeof node !== 'object' || node === null) {
+      return false;
+    }
+
+    if (Array.isArray(node)) {
+      for (const item of node) {
+        if (traverse(item, visitedRefs, pathRefs)) {
+          return true;
+        }
+      }
+      return false;
+    }
+
+    if ('$ref' in node && typeof node.$ref === 'string') {
+      const ref = node.$ref;
+      if (ref === '#/' || pathRefs.has(ref)) {
+        // A ref to just '#/' is always a cycle.
+        return true; // Cycle detected!
+      }
+      if (visitedRefs.has(ref)) {
+        return false; // Bail early, we have checked this ref before.
+      }
+
+      const resolvedNode = resolveRef(ref);
+      if (resolvedNode) {
+        // Add it to both visited and the current path
+        visitedRefs.add(ref);
+        pathRefs.add(ref);
+        const hasCycle = traverse(resolvedNode, visitedRefs, pathRefs);
+        pathRefs.delete(ref); // Backtrack, leaving it in visited
+        return hasCycle;
+      }
+    }
+
+    // Crawl all the properties of node
+    for (const key in node) {
+      if (Object.prototype.hasOwnProperty.call(node, key)) {
+        if (
+          traverse(
+            (node as Record<string, unknown>)[key],
+            visitedRefs,
+            pathRefs,
+          )
+        ) {
+          return true;
+        }
+      }
+    }
+
+    return false;
+  }
+
+  return traverse(schema, new Set<string>(), new Set<string>());
+}
+
 export type ToolResultDisplay = string | FileDiff;
 
 export interface FileDiff {

From b87b436ebce46f13701fdec0fa1e6974d604a958 Mon Sep 17 00:00:00 2001
From: Gaurav <39389231+gsquared94@users.noreply.github.com>
Date: Tue, 5 Aug 2025 19:24:40 -0700
Subject: [PATCH 004/107] refactor: use `google-github-actions/run-gemini-cli`
 action (#5643)

---
 .../gemini-automated-issue-triage.yml         | 127 +++++++++++++-----
 .../gemini-scheduled-issue-triage.yml         | 121 +++++++++++------
 2 files changed, 168 insertions(+), 80 deletions(-)

diff --git a/.github/workflows/gemini-automated-issue-triage.yml b/.github/workflows/gemini-automated-issue-triage.yml
index 63aa0742..495ccee1 100644
--- a/.github/workflows/gemini-automated-issue-triage.yml
+++ b/.github/workflows/gemini-automated-issue-triage.yml
@@ -1,56 +1,95 @@
-name: Gemini Automated Issue Triage
+name: '🏷️ Gemini Automated Issue Triage'
 
 on:
   issues:
-    types: [opened, reopened]
+    types:
+      - 'opened'
+      - 'reopened'
+  issue_comment:
+    types:
+      - 'created'
+  workflow_dispatch:
+    inputs:
+      issue_number:
+        description: 'issue number to triage'
+        required: true
+        type: 'number'
+
+concurrency:
+  group: '${{ github.workflow }}-${{ github.event.issue.number }}'
+  cancel-in-progress: true
+
+defaults:
+  run:
+    shell: 'bash'
+
+permissions:
+  contents: 'read'
+  id-token: 'write'
+  issues: 'write'
+  statuses: 'write'
 
 jobs:
   triage-issue:
+    if: >
+      github.repository == 'google-gemini/gemini-cli' &&
+      (github.event_name == 'issues' ||
+       github.event_name == 'workflow_dispatch' ||
+       (github.event_name == 'issue_comment' &&
+       contains(github.event.comment.body, '@gemini-cli /triage') &&
+       (github.event.comment.author_association == 'OWNER' ||
+        github.event.comment.author_association == 'MEMBER' ||
+        github.event.comment.author_association == 'COLLABORATOR')))
     timeout-minutes: 5
-    if: ${{ github.repository == 'google-gemini/gemini-cli' }}
-    permissions:
-      issues: write
-      contents: read
-      id-token: write
-    concurrency:
-      group: ${{ github.workflow }}-${{ github.event.issue.number }}
-      cancel-in-progress: true
-    runs-on: ubuntu-latest
-    steps:
-      - name: Generate GitHub App Token
-        id: generate_token
-        uses: actions/create-github-app-token@df432ceedc7162793a195dd1713ff69aefc7379e # v2
-        with:
-          app-id: ${{ secrets.APP_ID }}
-          private-key: ${{ secrets.PRIVATE_KEY }}
+    runs-on: 'ubuntu-latest'
 
-      - name: Run Gemini Issue Triage
-        uses: google-gemini/gemini-cli-action@df3f890f003d28c60a2a09d2c29e0126e4d1e2ff
-        env:
-          GITHUB_TOKEN: ${{ steps.generate_token.outputs.token }}
-          ISSUE_TITLE: ${{ github.event.issue.title }}
-          ISSUE_BODY: ${{ github.event.issue.body }}
+    steps:
+      - name: 'Checkout repository'
+        uses: 'actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683'
+
+      - name: 'Generate GitHub App Token'
+        id: 'generate_token'
+        uses: 'actions/create-github-app-token@df432ceedc7162793a195dd1713ff69aefc7379e'
         with:
-          version: 0.1.8-rc.0
-          GEMINI_API_KEY: ${{ secrets.GEMINI_API_KEY }}
-          OTLP_GCP_WIF_PROVIDER: ${{ secrets.OTLP_GCP_WIF_PROVIDER }}
-          OTLP_GOOGLE_CLOUD_PROJECT: ${{ secrets.OTLP_GOOGLE_CLOUD_PROJECT }}
-          settings_json: |
+          app-id: '${{ secrets.APP_ID }}'
+          private-key: '${{ secrets.PRIVATE_KEY }}'
+
+      - name: 'Run Gemini Issue Triage'
+        uses: 'google-github-actions/run-gemini-cli@68d5a6d2e31ff01029205c58c6bf81cb3d72910b'
+        id: 'gemini_issue_triage'
+        env:
+          GITHUB_TOKEN: '${{ steps.generate_token.outputs.token }}'
+          ISSUE_TITLE: '${{ github.event.issue.title }}'
+          ISSUE_BODY: '${{ github.event.issue.body }}'
+          ISSUE_NUMBER: '${{ github.event.issue.number }}'
+          REPOSITORY: '${{ github.repository }}'
+        with:
+          gcp_workload_identity_provider: '${{ vars.GCP_WIF_PROVIDER }}'
+          gcp_project_id: '${{ vars.GOOGLE_CLOUD_PROJECT }}'
+          gcp_location: '${{ vars.GOOGLE_CLOUD_LOCATION }}'
+          gcp_service_account: '${{ vars.SERVICE_ACCOUNT_EMAIL }}'
+          gemini_api_key: '${{ secrets.GEMINI_API_KEY }}'
+          use_vertex_ai: '${{ vars.GOOGLE_GENAI_USE_VERTEXAI }}'
+          use_gemini_code_assist: '${{ vars.GOOGLE_GENAI_USE_GCA }}'
+          settings: |-
             {
+              "maxSessionTurns": 25,
               "coreTools": [
                 "run_shell_command(gh label list)",
-                "run_shell_command(gh issue edit)",
-                "run_shell_command(gh issue list)"
+                "run_shell_command(gh issue edit)"
               ],
               "telemetry": {
                 "enabled": true,
                 "target": "gcp"
-              },
-              "sandbox": false
+              }
             }
-          prompt: |
+          prompt: |-
+            ## Role
+
             You are an issue triage assistant. Analyze the current GitHub issues apply the most appropriate existing labels. Do not remove labels titled help wanted or good first issue.
-            Steps:
+
+            ## Steps
+
             1. Run: `gh label list --repo ${{ github.repository }} --limit 100` to get all available labels.
             2. Review the issue title, body and any comments provided in the environment variables.
             3. Ignore any existing priorities or tags on the issue. Just report your findings.
@@ -59,7 +98,9 @@ jobs:
             7. For each issue please check if CLI version is present, this is usually in the output of the /about command  and will look like 0.1.5 for anything more than 6 versions older than the most recent should add the status/need-retesting label
             8. If you see that the issue doesn’t look like it has sufficient information recommend the status/need-information label
             9. Use Area definitions mentioned below to help you narrow down issues
-            Guidelines:
+
+            ## Guidelines
+
             - Only use labels that already exist in the repository.
             - Do not add comments or modify the issue content.
             - Triage only the current issue.
@@ -143,3 +184,17 @@ jobs:
             - could also pertain to latency,
             - other general software performance like, memory usage, CPU consumption, and algorithmic efficiency.
             - Switching models from one to the other unexpectedly.
+
+      - name: 'Post Issue Triage Failure Comment'
+        if: |-
+          ${{ failure() && steps.gemini_issue_triage.outcome == 'failure' }}
+        uses: 'actions/github-script@60a0d83039c74a4aee543508d2ffcb1c3799cdea'
+        with:
+          github-token: '${{ steps.generate_token.outputs.token }}'
+          script: |-
+            github.rest.issues.createComment({
+              owner: '${{ github.repository }}'.split('/')[0],
+              repo: '${{ github.repository }}'.split('/')[1],
+              issue_number: '${{ github.event.issue.number }}',
+              body: 'There is a problem with the Gemini CLI issue triaging. Please check the [action logs](${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}) for details.'
+            })
diff --git a/.github/workflows/gemini-scheduled-issue-triage.yml b/.github/workflows/gemini-scheduled-issue-triage.yml
index 7e083c84..f8ce8dab 100644
--- a/.github/workflows/gemini-scheduled-issue-triage.yml
+++ b/.github/workflows/gemini-scheduled-issue-triage.yml
@@ -1,76 +1,107 @@
-name: Gemini Scheduled Issue Triage
+name: '📋 Gemini Scheduled Issue Triage'
 
 on:
   schedule:
     - cron: '0 * * * *' # Runs every hour
-  workflow_dispatch: {}
+  workflow_dispatch:
+
+concurrency:
+  group: '${{ github.workflow }}'
+  cancel-in-progress: true
+
+defaults:
+  run:
+    shell: 'bash'
+
+permissions:
+  contents: 'read'
+  id-token: 'write'
+  issues: 'write'
+  statuses: 'write'
 
 jobs:
   triage-issues:
     timeout-minutes: 10
     if: ${{ github.repository == 'google-gemini/gemini-cli' }}
-    runs-on: ubuntu-latest
-    permissions:
-      contents: read
-      id-token: write
-      issues: write
+    runs-on: 'ubuntu-latest'
+
     steps:
-      - name: Generate GitHub App Token
-        id: generate_token
-        uses: actions/create-github-app-token@df432ceedc7162793a195dd1713ff69aefc7379e # v2
+      - name: 'Checkout repository'
+        uses: 'actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683' # ratchet:actions/checkout@v4
+
+      - name: 'Generate GitHub App Token'
+        id: 'generate_token'
+        uses: 'actions/create-github-app-token@df432ceedc7162793a195dd1713ff69aefc7379e' # ratchet:actions/create-github-app-token@v2
         with:
-          app-id: ${{ secrets.APP_ID }}
-          private-key: ${{ secrets.PRIVATE_KEY }}
+          app-id: '${{ secrets.APP_ID }}'
+          private-key: '${{ secrets.PRIVATE_KEY }}'
 
-      - name: Find untriaged issues
-        id: find_issues
+      - name: 'Find untriaged issues'
+        id: 'find_issues'
         env:
-          GITHUB_TOKEN: ${{ steps.generate_token.outputs.token }}
-        run: |
-          echo "🔍 Finding issues without labels..."
-          NO_LABEL_ISSUES=$(gh issue list --repo ${{ github.repository }} --search "is:open is:issue no:label" --json number,title,body)
+          GITHUB_TOKEN: '${{ steps.generate_token.outputs.token }}'
+          GITHUB_REPOSITORY: '${{ github.repository }}'
+          GITHUB_OUTPUT: '${{ github.output }}'
+        run: |-
+          set -euo pipefail
 
-          echo "🏷️ Finding issues that need triage..."
-          NEED_TRIAGE_ISSUES=$(gh issue list --repo ${{ github.repository }} --search "is:open is:issue label:\"status/need-triage\"" --json number,title,body)
+          echo '🔍 Finding issues without labels...'
+          NO_LABEL_ISSUES="$(gh issue list --repo "${GITHUB_REPOSITORY}" \
+            --search 'is:open is:issue no:label' --json number,title,body)"
 
-          echo "🔄 Merging and deduplicating issues..."
-          ISSUES=$(echo "$NO_LABEL_ISSUES" "$NEED_TRIAGE_ISSUES" | jq -c -s 'add | unique_by(.number)')
+          echo '🏷️ Finding issues that need triage...'
+          NEED_TRIAGE_ISSUES="$(gh issue list --repo "${GITHUB_REPOSITORY}" \
+            --search 'is:open is:issue label:"status/needs-triage"' --json number,title,body)"
 
-          echo "📝 Setting output for GitHub Actions..."
-          echo "issues_to_triage=$ISSUES" >> "$GITHUB_OUTPUT"
+          echo '🔄 Merging and deduplicating issues...'
+          ISSUES="$(echo "${NO_LABEL_ISSUES}" "${NEED_TRIAGE_ISSUES}" | jq -c -s 'add | unique_by(.number)')"
 
-          echo "✅ Found $(echo "$ISSUES" | jq 'length') issues to triage! 🎯"
+          echo '📝 Setting output for GitHub Actions...'
+          echo "issues_to_triage=${ISSUES}" >> "${GITHUB_OUTPUT}"
 
-      - name: Run Gemini Issue Triage
-        if: steps.find_issues.outputs.issues_to_triage != '[]'
-        uses: google-gemini/gemini-cli-action@df3f890f003d28c60a2a09d2c29e0126e4d1e2ff
+          ISSUE_COUNT="$(echo "${ISSUES}" | jq 'length')"
+          echo "✅ Found ${ISSUE_COUNT} issues to triage! 🎯"
+
+      - name: 'Run Gemini Issue Triage'
+        if: |-
+          ${{ steps.find_issues.outputs.issues_to_triage != '[]' }}
+        uses: 'google-github-actions/run-gemini-cli@68d5a6d2e31ff01029205c58c6bf81cb3d72910b'
+        id: 'gemini_issue_triage'
         env:
-          GITHUB_TOKEN: ${{ steps.generate_token.outputs.token }}
-          ISSUES_TO_TRIAGE: ${{ steps.find_issues.outputs.issues_to_triage }}
-          REPOSITORY: ${{ github.repository }}
+          GITHUB_TOKEN: '${{ steps.generate_token.outputs.token }}'
+          ISSUES_TO_TRIAGE: '${{ steps.find_issues.outputs.issues_to_triage }}'
+          REPOSITORY: '${{ github.repository }}'
         with:
-          version: 0.1.8-rc.0
-          GEMINI_API_KEY: ${{ secrets.GEMINI_API_KEY }}
-          OTLP_GCP_WIF_PROVIDER: ${{ secrets.OTLP_GCP_WIF_PROVIDER }}
-          OTLP_GOOGLE_CLOUD_PROJECT: ${{ secrets.OTLP_GOOGLE_CLOUD_PROJECT }}
-          settings_json: |
+          gcp_workload_identity_provider: '${{ vars.GCP_WIF_PROVIDER }}'
+          gcp_project_id: '${{ vars.GOOGLE_CLOUD_PROJECT }}'
+          gcp_location: '${{ vars.GOOGLE_CLOUD_LOCATION }}'
+          gcp_service_account: '${{ vars.SERVICE_ACCOUNT_EMAIL }}'
+          gemini_api_key: '${{ secrets.GEMINI_API_KEY }}'
+          use_vertex_ai: '${{ vars.GOOGLE_GENAI_USE_VERTEXAI }}'
+          use_gemini_code_assist: '${{ vars.GOOGLE_GENAI_USE_GCA }}'
+          settings: |-
             {
+              "maxSessionTurns": 25,
               "coreTools": [
                 "run_shell_command(echo)",
                 "run_shell_command(gh label list)",
                 "run_shell_command(gh issue edit)",
-                "run_shell_command(gh issue list)",
                 "run_shell_command(gh issue view)"
               ],
               "telemetry": {
                 "enabled": true,
                 "target": "gcp"
-              },
-              "sandbox": false
+              }
             }
-          prompt: |
-            You are an issue triage assistant. Analyze the current GitHub issues apply the most appropriate existing labels. 
-            Steps:
+          prompt: |-
+            ## Role
+
+            You are an issue triage assistant. Analyze issues and apply
+            appropriate labels. Use the available tools to gather information;
+            do not ask for information to be provided.
+
+            ## Steps
+
             1. Run: `gh label list --repo ${{ github.repository }} --limit 100` to get all available labels.
             2. Check environment variable for issues to triage: $ISSUES_TO_TRIAGE (JSON array of issues)
             3. Review the issue title, body and any comments provided in the environment variables.
@@ -95,8 +126,10 @@ jobs:
               - After applying appropriate labels to an issue, remove the "status/need-triage" label if present: `gh issue edit ISSUE_NUMBER --repo ${{ github.repository }} --remove-label "status/need-triage"`
               - Execute one `gh issue edit` command per issue, wait for success before proceeding to the next
             Process each issue sequentially and confirm each labeling operation before moving to the next issue.
-            Guidelines:
-              - Only use labels that already exist in the repository.
+
+            ## Guidelines
+
+            - Only use labels that already exist in the repository.
               - Do not add comments or modify the issue content.
               - Do not remove labels titled help wanted or good first issue.
               - Triage only the current issue.

From be3aabaea6741091e7b2bd4a131f51148c7c2886 Mon Sep 17 00:00:00 2001
From: Lee James <40045512+leehagoodjames@users.noreply.github.com>
Date: Tue, 5 Aug 2025 22:59:25 -0400
Subject: [PATCH 005/107] docs(setup-github): Inform user of the next steps
 after running slash command (#5644)

Co-authored-by: gemini-code-assist[bot] <176961590+gemini-code-assist[bot]@users.noreply.github.com>
---
 packages/cli/src/ui/commands/setupGithubCommand.ts | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/packages/cli/src/ui/commands/setupGithubCommand.ts b/packages/cli/src/ui/commands/setupGithubCommand.ts
index e330cfab..445c0e76 100644
--- a/packages/cli/src/ui/commands/setupGithubCommand.ts
+++ b/packages/cli/src/ui/commands/setupGithubCommand.ts
@@ -44,7 +44,8 @@ export const setupGithubCommand: SlashCommand = {
         const fileName = path.basename(workflow);
         return `curl -fsSL -o "${gitRootRepo}/.github/workflows/${fileName}" "${workflowBaseUrl}/${workflow}"`;
       }),
-      'echo "Workflows downloaded successfully."',
+      'echo "Workflows downloaded successfully. Follow steps in https://github.com/google-github-actions/run-gemini-cli/blob/v0/README.md#quick-start (skipping the /setup-github step) to complete setup."',
+      'open https://github.com/google-github-actions/run-gemini-cli/blob/v0/README.md#quick-start',
     ].join(' && ');
     return {
       type: 'tool',

From 7fa2d7be176369f4a0847741a7df88d20f2e2152 Mon Sep 17 00:00:00 2001
From: Lee James <40045512+leehagoodjames@users.noreply.github.com>
Date: Tue, 5 Aug 2025 23:21:36 -0400
Subject: [PATCH 006/107] doc(lint): fix docs on how to run linter in "fix"
 mode (#5647)

---
 docs/integration-tests.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/docs/integration-tests.md b/docs/integration-tests.md
index 53ddd155..7a4c8489 100644
--- a/docs/integration-tests.md
+++ b/docs/integration-tests.md
@@ -109,10 +109,10 @@ To check for linting errors, run the following command:
 npm run lint
 ```
 
-You can include the `--fix` flag in the command to automatically fix any fixable linting errors:
+You can include the `:fix` flag in the command to automatically fix any fixable linting errors:
 
 ```bash
-npm run lint --fix
+npm run lint:fix
 ```
 
 ## Directory structure

From 2fcaa302da40f68b7e9a494a11c450def0a1e4d4 Mon Sep 17 00:00:00 2001
From: Jerop Kipruto <jerop@google.com>
Date: Wed, 6 Aug 2025 13:01:42 +0900
Subject: [PATCH 007/107] docs: add GitHub Integration section to README
 (#5649)

---
 README.md | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/README.md b/README.md
index ad531676..b1c8f38c 100644
--- a/README.md
+++ b/README.md
@@ -12,6 +12,7 @@ With the Gemini CLI you can:
 - Query and edit large codebases in and beyond Gemini's 1M token context window.
 - Generate new apps from PDFs or sketches, using Gemini's multimodal capabilities.
 - Automate operational tasks, like querying pull requests or handling complex rebases.
+- Integrate with GitHub: Use the [Gemini CLI GitHub Action](https://github.com/google-github-actions/run-gemini-cli) for automated PR reviews, issue triage, and on-demand AI assistance directly in your repositories.
 - Use tools and MCP servers to connect new capabilities, including [media generation with Imagen,
   Veo or Lyria](https://github.com/GoogleCloudPlatform/vertex-ai-creative-studio/tree/main/experiments/mcp-genmedia)
 - Ground your queries with the [Google Search](https://ai.google.dev/gemini-api/docs/grounding)
@@ -128,6 +129,15 @@ gemini
 Head over to the [troubleshooting guide](docs/troubleshooting.md) if you're
 having issues.
 
+## GitHub Integration
+
+Integrate Gemini CLI directly into your GitHub workflows with the [**Gemini CLI GitHub Action**](https://github.com/google-github-actions/run-gemini-cli). Key features include:
+
+- **Pull Request Reviews**: Automatically review pull requests when they're opened.
+- **Issue Triage**: Automatically triage and label GitHub issues.
+- **On-demand Collaboration**: Mention `@gemini-cli` in issues and pull requests for assistance and task delegation.
+- **Custom Workflows**: Set up your own scheduled tasks and event-driven automations.
+
 ## Popular tasks
 
 ### Explore a new codebase

From a0990380b5f96cc826bd8be50b12e8d034d0eccd Mon Sep 17 00:00:00 2001
From: Gaurav <39389231+gsquared94@users.noreply.github.com>
Date: Tue, 5 Aug 2025 22:26:27 -0700
Subject: [PATCH 008/107] fix:missing coreTool in new workflow setup (#5656)

---
 .github/workflows/gemini-automated-issue-triage.yml | 3 ++-
 .github/workflows/gemini-scheduled-issue-triage.yml | 3 ++-
 2 files changed, 4 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/gemini-automated-issue-triage.yml b/.github/workflows/gemini-automated-issue-triage.yml
index 495ccee1..d29484f7 100644
--- a/.github/workflows/gemini-automated-issue-triage.yml
+++ b/.github/workflows/gemini-automated-issue-triage.yml
@@ -76,7 +76,8 @@ jobs:
               "maxSessionTurns": 25,
               "coreTools": [
                 "run_shell_command(gh label list)",
-                "run_shell_command(gh issue edit)"
+                "run_shell_command(gh issue edit)",
+                "run_shell_command(gh issue list)"
               ],
               "telemetry": {
                 "enabled": true,
diff --git a/.github/workflows/gemini-scheduled-issue-triage.yml b/.github/workflows/gemini-scheduled-issue-triage.yml
index f8ce8dab..4e6f8a00 100644
--- a/.github/workflows/gemini-scheduled-issue-triage.yml
+++ b/.github/workflows/gemini-scheduled-issue-triage.yml
@@ -86,7 +86,8 @@ jobs:
                 "run_shell_command(echo)",
                 "run_shell_command(gh label list)",
                 "run_shell_command(gh issue edit)",
-                "run_shell_command(gh issue view)"
+                "run_shell_command(gh issue view)",
+                "run_shell_command(gh issue list)"
               ],
               "telemetry": {
                 "enabled": true,

From 8b1d5a2e3c84e488d90184e7da856cf1130ea5ef Mon Sep 17 00:00:00 2001
From: Yash Velagapudi <46730550+yashv6655@users.noreply.github.com>
Date: Tue, 5 Aug 2025 23:15:53 -0700
Subject: [PATCH 009/107] fix(core): Treat .mts files as TypeScript modules
 instead of video files (#5492)

Co-authored-by: Jacob Richman <jacob314@gmail.com>
---
 packages/core/src/utils/fileUtils.test.ts | 6 +++++-
 packages/core/src/utils/fileUtils.ts      | 7 ++++---
 2 files changed, 9 insertions(+), 4 deletions(-)

diff --git a/packages/core/src/utils/fileUtils.test.ts b/packages/core/src/utils/fileUtils.test.ts
index bcdf3fe7..fb6b6820 100644
--- a/packages/core/src/utils/fileUtils.test.ts
+++ b/packages/core/src/utils/fileUtils.test.ts
@@ -196,9 +196,13 @@ describe('fileUtils', () => {
       vi.restoreAllMocks(); // Restore spies on actualNodeFs
     });
 
-    it('should detect typescript type by extension (ts)', async () => {
+    it('should detect typescript type by extension (ts, mts, cts, tsx)', async () => {
       expect(await detectFileType('file.ts')).toBe('text');
       expect(await detectFileType('file.test.ts')).toBe('text');
+      expect(await detectFileType('file.mts')).toBe('text');
+      expect(await detectFileType('vite.config.mts')).toBe('text');
+      expect(await detectFileType('file.cts')).toBe('text');
+      expect(await detectFileType('component.tsx')).toBe('text');
     });
 
     it('should detect image type by extension (png)', async () => {
diff --git a/packages/core/src/utils/fileUtils.ts b/packages/core/src/utils/fileUtils.ts
index 96f4b36c..a153d205 100644
--- a/packages/core/src/utils/fileUtils.ts
+++ b/packages/core/src/utils/fileUtils.ts
@@ -122,9 +122,10 @@ export async function detectFileType(
 ): Promise<'text' | 'image' | 'pdf' | 'audio' | 'video' | 'binary' | 'svg'> {
   const ext = path.extname(filePath).toLowerCase();
 
-  // The mimetype for "ts" is MPEG transport stream (a video format) but we want
-  // to assume these are typescript files instead.
-  if (ext === '.ts') {
+  // The mimetype for various TypeScript extensions (ts, mts, cts, tsx) can be
+  // MPEG transport stream (a video format), but we want to assume these are
+  // TypeScript files instead.
+  if (['.ts', '.mts', '.cts'].includes(ext)) {
     return 'text';
   }
 

From aab850668c99e1c39a55036069d9f4b06ca458f4 Mon Sep 17 00:00:00 2001
From: Bryant Chandler <brychanrobot@gmail.com>
Date: Tue, 5 Aug 2025 23:33:27 -0700
Subject: [PATCH 010/107] feat(file-search): Add support for non-recursive file
 search (#5648)

Co-authored-by: Jacob Richman <jacob314@gmail.com>
---
 .../cli/src/ui/hooks/useAtCompletion.test.ts  |  38 +++++
 packages/cli/src/ui/hooks/useAtCompletion.ts  |   3 +
 .../src/utils/filesearch/crawlCache.test.ts   |  11 ++
 .../core/src/utils/filesearch/crawlCache.ts   |   4 +
 .../src/utils/filesearch/fileSearch.test.ts   | 145 ++++++++++++++++++
 .../core/src/utils/filesearch/fileSearch.ts   |   7 +
 6 files changed, 208 insertions(+)

diff --git a/packages/cli/src/ui/hooks/useAtCompletion.test.ts b/packages/cli/src/ui/hooks/useAtCompletion.test.ts
index 58602d99..43289992 100644
--- a/packages/cli/src/ui/hooks/useAtCompletion.test.ts
+++ b/packages/cli/src/ui/hooks/useAtCompletion.test.ts
@@ -50,6 +50,7 @@ describe('useAtCompletion', () => {
         respectGitIgnore: true,
         respectGeminiIgnore: true,
       })),
+      getEnableRecursiveFileSearch: () => true,
     } as unknown as Config;
     vi.clearAllMocks();
   });
@@ -431,5 +432,42 @@ describe('useAtCompletion', () => {
       await cleanupTmpDir(rootDir1);
       await cleanupTmpDir(rootDir2);
     });
+
+    it('should perform a non-recursive search when enableRecursiveFileSearch is false', async () => {
+      const structure: FileSystemStructure = {
+        'file.txt': '',
+        src: {
+          'index.js': '',
+        },
+      };
+      testRootDir = await createTmpDir(structure);
+
+      const nonRecursiveConfig = {
+        getEnableRecursiveFileSearch: () => false,
+        getFileFilteringOptions: vi.fn(() => ({
+          respectGitIgnore: true,
+          respectGeminiIgnore: true,
+        })),
+      } as unknown as Config;
+
+      const { result } = renderHook(() =>
+        useTestHarnessForAtCompletion(
+          true,
+          '',
+          nonRecursiveConfig,
+          testRootDir,
+        ),
+      );
+
+      await waitFor(() => {
+        expect(result.current.suggestions.length).toBeGreaterThan(0);
+      });
+
+      // Should only contain top-level items
+      expect(result.current.suggestions.map((s) => s.value)).toEqual([
+        'src/',
+        'file.txt',
+      ]);
+    });
   });
 });
diff --git a/packages/cli/src/ui/hooks/useAtCompletion.ts b/packages/cli/src/ui/hooks/useAtCompletion.ts
index e63a707f..82439c14 100644
--- a/packages/cli/src/ui/hooks/useAtCompletion.ts
+++ b/packages/cli/src/ui/hooks/useAtCompletion.ts
@@ -165,6 +165,9 @@ export function useAtCompletion(props: UseAtCompletionProps): void {
             config?.getFileFilteringOptions()?.respectGeminiIgnore ?? true,
           cache: true,
           cacheTtl: 30, // 30 seconds
+          maxDepth: !(config?.getEnableRecursiveFileSearch() ?? true)
+            ? 0
+            : undefined,
         });
         await searcher.initialize();
         fileSearch.current = searcher;
diff --git a/packages/core/src/utils/filesearch/crawlCache.test.ts b/packages/core/src/utils/filesearch/crawlCache.test.ts
index 2feab61a..c8ca0df2 100644
--- a/packages/core/src/utils/filesearch/crawlCache.test.ts
+++ b/packages/core/src/utils/filesearch/crawlCache.test.ts
@@ -26,6 +26,17 @@ describe('CrawlCache', () => {
       const key2 = getCacheKey('/foo', 'baz');
       expect(key1).not.toBe(key2);
     });
+
+    it('should generate a different hash for different maxDepth values', () => {
+      const key1 = getCacheKey('/foo', 'bar', 1);
+      const key2 = getCacheKey('/foo', 'bar', 2);
+      const key3 = getCacheKey('/foo', 'bar', undefined);
+      const key4 = getCacheKey('/foo', 'bar');
+      expect(key1).not.toBe(key2);
+      expect(key1).not.toBe(key3);
+      expect(key2).not.toBe(key3);
+      expect(key3).toBe(key4);
+    });
   });
 
   describe('in-memory cache operations', () => {
diff --git a/packages/core/src/utils/filesearch/crawlCache.ts b/packages/core/src/utils/filesearch/crawlCache.ts
index 3cc948c6..b905c9df 100644
--- a/packages/core/src/utils/filesearch/crawlCache.ts
+++ b/packages/core/src/utils/filesearch/crawlCache.ts
@@ -17,10 +17,14 @@ const cacheTimers = new Map<string, NodeJS.Timeout>();
 export const getCacheKey = (
   directory: string,
   ignoreContent: string,
+  maxDepth?: number,
 ): string => {
   const hash = crypto.createHash('sha256');
   hash.update(directory);
   hash.update(ignoreContent);
+  if (maxDepth !== undefined) {
+    hash.update(String(maxDepth));
+  }
   return hash.digest('hex');
 };
 
diff --git a/packages/core/src/utils/filesearch/fileSearch.test.ts b/packages/core/src/utils/filesearch/fileSearch.test.ts
index b804d623..a7f59f91 100644
--- a/packages/core/src/utils/filesearch/fileSearch.test.ts
+++ b/packages/core/src/utils/filesearch/fileSearch.test.ts
@@ -446,6 +446,46 @@ describe('FileSearch', () => {
 
       expect(crawlSpy).toHaveBeenCalledTimes(1);
     });
+
+    it('should miss the cache when maxDepth changes', async () => {
+      tmpDir = await createTmpDir({ 'file1.js': '' });
+      const getOptions = (maxDepth?: number) => ({
+        projectRoot: tmpDir,
+        useGitignore: false,
+        useGeminiignore: false,
+        ignoreDirs: [],
+        cache: true,
+        cacheTtl: 10000,
+        maxDepth,
+      });
+
+      // 1. First search with maxDepth: 1, should trigger a crawl.
+      const fs1 = new FileSearch(getOptions(1));
+      const crawlSpy1 = vi.spyOn(
+        fs1 as FileSearchWithPrivateMethods,
+        'performCrawl',
+      );
+      await fs1.initialize();
+      expect(crawlSpy1).toHaveBeenCalledTimes(1);
+
+      // 2. Second search with maxDepth: 2, should be a cache miss and trigger a crawl.
+      const fs2 = new FileSearch(getOptions(2));
+      const crawlSpy2 = vi.spyOn(
+        fs2 as FileSearchWithPrivateMethods,
+        'performCrawl',
+      );
+      await fs2.initialize();
+      expect(crawlSpy2).toHaveBeenCalledTimes(1);
+
+      // 3. Third search with maxDepth: 1 again, should be a cache hit.
+      const fs3 = new FileSearch(getOptions(1));
+      const crawlSpy3 = vi.spyOn(
+        fs3 as FileSearchWithPrivateMethods,
+        'performCrawl',
+      );
+      await fs3.initialize();
+      expect(crawlSpy3).not.toHaveBeenCalled();
+    });
   });
 
   it('should handle empty or commented-only ignore files', async () => {
@@ -639,4 +679,109 @@ describe('FileSearch', () => {
     // 3. Assert that the maxResults limit was respected, even with a cache hit.
     expect(limitedResults).toEqual(['file1.js', 'file2.js']);
   });
+
+  describe('with maxDepth', () => {
+    beforeEach(async () => {
+      tmpDir = await createTmpDir({
+        'file-root.txt': '',
+        level1: {
+          'file-level1.txt': '',
+          level2: {
+            'file-level2.txt': '',
+            level3: {
+              'file-level3.txt': '',
+            },
+          },
+        },
+      });
+    });
+
+    it('should only search top-level files when maxDepth is 0', async () => {
+      const fileSearch = new FileSearch({
+        projectRoot: tmpDir,
+        useGitignore: false,
+        useGeminiignore: false,
+        ignoreDirs: [],
+        cache: false,
+        cacheTtl: 0,
+        maxDepth: 0,
+      });
+
+      await fileSearch.initialize();
+      const results = await fileSearch.search('');
+
+      expect(results).toEqual(['level1/', 'file-root.txt']);
+    });
+
+    it('should search one level deep when maxDepth is 1', async () => {
+      const fileSearch = new FileSearch({
+        projectRoot: tmpDir,
+        useGitignore: false,
+        useGeminiignore: false,
+        ignoreDirs: [],
+        cache: false,
+        cacheTtl: 0,
+        maxDepth: 1,
+      });
+
+      await fileSearch.initialize();
+      const results = await fileSearch.search('');
+
+      expect(results).toEqual([
+        'level1/',
+        'level1/level2/',
+        'file-root.txt',
+        'level1/file-level1.txt',
+      ]);
+    });
+
+    it('should search two levels deep when maxDepth is 2', async () => {
+      const fileSearch = new FileSearch({
+        projectRoot: tmpDir,
+        useGitignore: false,
+        useGeminiignore: false,
+        ignoreDirs: [],
+        cache: false,
+        cacheTtl: 0,
+        maxDepth: 2,
+      });
+
+      await fileSearch.initialize();
+      const results = await fileSearch.search('');
+
+      expect(results).toEqual([
+        'level1/',
+        'level1/level2/',
+        'level1/level2/level3/',
+        'file-root.txt',
+        'level1/file-level1.txt',
+        'level1/level2/file-level2.txt',
+      ]);
+    });
+
+    it('should perform a full recursive search when maxDepth is undefined', async () => {
+      const fileSearch = new FileSearch({
+        projectRoot: tmpDir,
+        useGitignore: false,
+        useGeminiignore: false,
+        ignoreDirs: [],
+        cache: false,
+        cacheTtl: 0,
+        maxDepth: undefined, // Explicitly undefined
+      });
+
+      await fileSearch.initialize();
+      const results = await fileSearch.search('');
+
+      expect(results).toEqual([
+        'level1/',
+        'level1/level2/',
+        'level1/level2/level3/',
+        'file-root.txt',
+        'level1/file-level1.txt',
+        'level1/level2/file-level2.txt',
+        'level1/level2/level3/file-level3.txt',
+      ]);
+    });
+  });
 });
diff --git a/packages/core/src/utils/filesearch/fileSearch.ts b/packages/core/src/utils/filesearch/fileSearch.ts
index 5915821a..db14bc65 100644
--- a/packages/core/src/utils/filesearch/fileSearch.ts
+++ b/packages/core/src/utils/filesearch/fileSearch.ts
@@ -19,6 +19,7 @@ export type FileSearchOptions = {
   useGeminiignore: boolean;
   cache: boolean;
   cacheTtl: number;
+  maxDepth?: number;
 };
 
 export class AbortError extends Error {
@@ -215,6 +216,7 @@ export class FileSearch {
       const cacheKey = cache.getCacheKey(
         this.absoluteDir,
         this.ignore.getFingerprint(),
+        this.options.maxDepth,
       );
       const cachedResults = cache.read(cacheKey);
 
@@ -230,6 +232,7 @@ export class FileSearch {
       const cacheKey = cache.getCacheKey(
         this.absoluteDir,
         this.ignore.getFingerprint(),
+        this.options.maxDepth,
       );
       cache.write(cacheKey, this.allFiles, this.options.cacheTtl * 1000);
     }
@@ -257,6 +260,10 @@ export class FileSearch {
         return dirFilter(`${relativePath}/`);
       });
 
+    if (this.options.maxDepth !== undefined) {
+      api.withMaxDepth(this.options.maxDepth);
+    }
+
     return api.crawl(this.absoluteDir).withPromise();
   }
 

From b38f377c9a2672e88dd15119b38d908c0f00b54a Mon Sep 17 00:00:00 2001
From: Lee James <40045512+leehagoodjames@users.noreply.github.com>
Date: Wed, 6 Aug 2025 09:06:37 -0400
Subject: [PATCH 011/107] feat: Enable /setup-github to always run, and error
 appropriately (#5653)

Co-authored-by: Jacob Richman <jacob314@gmail.com>
---
 .../cli/src/services/BuiltinCommandLoader.ts  |  3 +--
 .../ui/commands/setupGithubCommand.test.ts    |  4 +++-
 .../cli/src/ui/commands/setupGithubCommand.ts | 19 ++++++++++++++-----
 3 files changed, 18 insertions(+), 8 deletions(-)

diff --git a/packages/cli/src/services/BuiltinCommandLoader.ts b/packages/cli/src/services/BuiltinCommandLoader.ts
index 46ecb37c..c09f7c61 100644
--- a/packages/cli/src/services/BuiltinCommandLoader.ts
+++ b/packages/cli/src/services/BuiltinCommandLoader.ts
@@ -32,7 +32,6 @@ import { themeCommand } from '../ui/commands/themeCommand.js';
 import { toolsCommand } from '../ui/commands/toolsCommand.js';
 import { vimCommand } from '../ui/commands/vimCommand.js';
 import { setupGithubCommand } from '../ui/commands/setupGithubCommand.js';
-import { isGitHubRepository } from '../utils/gitUtils.js';
 
 /**
  * Loads the core, hard-coded slash commands that are an integral part
@@ -74,7 +73,7 @@ export class BuiltinCommandLoader implements ICommandLoader {
       themeCommand,
       toolsCommand,
       vimCommand,
-      ...(isGitHubRepository() ? [setupGithubCommand] : []),
+      setupGithubCommand,
     ];
 
     return allDefinitions.filter((cmd): cmd is SlashCommand => cmd !== null);
diff --git a/packages/cli/src/ui/commands/setupGithubCommand.test.ts b/packages/cli/src/ui/commands/setupGithubCommand.test.ts
index 891c84e7..ae6378c7 100644
--- a/packages/cli/src/ui/commands/setupGithubCommand.test.ts
+++ b/packages/cli/src/ui/commands/setupGithubCommand.test.ts
@@ -61,6 +61,8 @@ describe('setupGithubCommand', () => {
     vi.mocked(child_process.execSync).mockReturnValue('');
     expect(() => {
       setupGithubCommand.action?.({} as CommandContext, '');
-    }).toThrow('Unable to determine the Git root directory.');
+    }).toThrow(
+      'Unable to determine the GitHub repository. /setup-github must be run from a git repository.',
+    );
   });
 });
diff --git a/packages/cli/src/ui/commands/setupGithubCommand.ts b/packages/cli/src/ui/commands/setupGithubCommand.ts
index 445c0e76..047e11eb 100644
--- a/packages/cli/src/ui/commands/setupGithubCommand.ts
+++ b/packages/cli/src/ui/commands/setupGithubCommand.ts
@@ -19,12 +19,21 @@ export const setupGithubCommand: SlashCommand = {
   description: 'Set up GitHub Actions',
   kind: CommandKind.BUILT_IN,
   action: (): SlashCommandActionReturn => {
-    const gitRootRepo = execSync('git rev-parse --show-toplevel', {
-      encoding: 'utf-8',
-    }).trim();
-
     if (!isGitHubRepository()) {
-      throw new Error('Unable to determine the Git root directory.');
+      throw new Error(
+        'Unable to determine the GitHub repository. /setup-github must be run from a git repository.',
+      );
+    }
+
+    let gitRootRepo: string;
+    try {
+      gitRootRepo = execSync('git rev-parse --show-toplevel', {
+        encoding: 'utf-8',
+      }).trim();
+    } catch {
+      throw new Error(
+        'Unable to determine the GitHub repository. /setup-github must be run from a git repository.',
+      );
     }
 
     const version = 'v0';

From ca4c745e3b620e3ac4eca24b610cc7b936c0a50d Mon Sep 17 00:00:00 2001
From: Jack Wotherspoon <jackwoth@google.com>
Date: Wed, 6 Aug 2025 11:52:29 -0400
Subject: [PATCH 012/107] feat(mcp): add `gemini mcp` commands for `add`,
 `remove` and `list` (#5481)

---
 docs/tools/mcp-server.md                     | 111 +++++++
 packages/cli/src/commands/mcp.test.ts        |  55 ++++
 packages/cli/src/commands/mcp.ts             |  27 ++
 packages/cli/src/commands/mcp/add.test.ts    |  88 +++++
 packages/cli/src/commands/mcp/add.ts         | 211 ++++++++++++
 packages/cli/src/commands/mcp/list.test.ts   | 154 +++++++++
 packages/cli/src/commands/mcp/list.ts        | 139 ++++++++
 packages/cli/src/commands/mcp/remove.test.ts |  69 ++++
 packages/cli/src/commands/mcp/remove.ts      |  60 ++++
 packages/cli/src/config/config.ts            | 323 ++++++++++---------
 10 files changed, 1082 insertions(+), 155 deletions(-)
 create mode 100644 packages/cli/src/commands/mcp.test.ts
 create mode 100644 packages/cli/src/commands/mcp.ts
 create mode 100644 packages/cli/src/commands/mcp/add.test.ts
 create mode 100644 packages/cli/src/commands/mcp/add.ts
 create mode 100644 packages/cli/src/commands/mcp/list.test.ts
 create mode 100644 packages/cli/src/commands/mcp/list.ts
 create mode 100644 packages/cli/src/commands/mcp/remove.test.ts
 create mode 100644 packages/cli/src/commands/mcp/remove.ts

diff --git a/docs/tools/mcp-server.md b/docs/tools/mcp-server.md
index 850c228e..17138bae 100644
--- a/docs/tools/mcp-server.md
+++ b/docs/tools/mcp-server.md
@@ -688,3 +688,114 @@ or, using positional arguments:
 ```
 
 When you run this command, the Gemini CLI executes the `prompts/get` method on the MCP server with the provided arguments. The server is responsible for substituting the arguments into the prompt template and returning the final prompt text. The CLI then sends this prompt to the model for execution. This provides a convenient way to automate and share common workflows.
+
+## Managing MCP Servers with `gemini mcp`
+
+While you can always configure MCP servers by manually editing your `settings.json` file, the Gemini CLI provides a convenient set of commands to manage your server configurations programmatically. These commands streamline the process of adding, listing, and removing MCP servers without needing to directly edit JSON files.
+
+### Adding a Server (`gemini mcp add`)
+
+The `add` command configures a new MCP server in your `settings.json`. Based on the scope (`-s, --scope`), it will be added to either the user config `~/.gemini/settings.json` or the project config `.gemini/settings.json` file.
+
+**Command:**
+
+```bash
+gemini mcp add [options] <name> <commandOrUrl> [args...]
+```
+
+- `<name>`: A unique name for the server.
+- `<commandOrUrl>`: The command to execute (for `stdio`) or the URL (for `http`/`sse`).
+- `[args...]`: Optional arguments for a `stdio` command.
+
+**Options (Flags):**
+
+- `-s, --scope`: Configuration scope (user or project). [default: "project"]
+- `-t, --transport`: Transport type (stdio, sse, http). [default: "stdio"]
+- `-e, --env`: Set environment variables (e.g. -e KEY=value).
+- `-H, --header`: Set HTTP headers for SSE and HTTP transports (e.g. -H "X-Api-Key: abc123" -H "Authorization: Bearer abc123").
+- `--timeout`: Set connection timeout in milliseconds.
+- `--trust`: Trust the server (bypass all tool call confirmation prompts).
+- `--description`: Set the description for the server.
+- `--include-tools`: A comma-separated list of tools to include.
+- `--exclude-tools`: A comma-separated list of tools to exclude.
+
+#### Adding an stdio server
+
+This is the default transport for running local servers.
+
+```bash
+# Basic syntax
+gemini mcp add <name> <command> [args...]
+
+# Example: Adding a local server
+gemini mcp add my-stdio-server -e API_KEY=123 /path/to/server arg1 arg2 arg3
+
+# Example: Adding a local python server
+gemini mcp add python-server python server.py --port 8080
+```
+
+#### Adding an HTTP server
+
+This transport is for servers that use the streamable HTTP transport.
+
+```bash
+# Basic syntax
+gemini mcp add --transport http <name> <url>
+
+# Example: Adding an HTTP server
+gemini mcp add --transport http http-server https://api.example.com/mcp/
+
+# Example: Adding an HTTP server with an authentication header
+gemini mcp add --transport http secure-http https://api.example.com/mcp/ --header "Authorization: Bearer abc123"
+```
+
+#### Adding an SSE server
+
+This transport is for servers that use Server-Sent Events (SSE).
+
+```bash
+# Basic syntax
+gemini mcp add --transport sse <name> <url>
+
+# Example: Adding an SSE server
+gemini mcp add --transport sse sse-server https://api.example.com/sse/
+
+# Example: Adding an SSE server with an authentication header
+gemini mcp add --transport sse secure-sse https://api.example.com/sse/ --header "Authorization: Bearer abc123"
+```
+
+### Listing Servers (`gemini mcp list`)
+
+To view all MCP servers currently configured, use the `list` command. It displays each server's name, configuration details, and connection status.
+
+**Command:**
+
+```bash
+gemini mcp list
+```
+
+**Example Output:**
+
+```sh
+✓ stdio-server: command: python3 server.py (stdio) - Connected
+✓ http-server: https://api.example.com/mcp (http) - Connected
+✗ sse-server: https://api.example.com/sse (sse) - Disconnected
+```
+
+### Removing a Server (`gemini mcp remove`)
+
+To delete a server from your configuration, use the `remove` command with the server's name.
+
+**Command:**
+
+```bash
+gemini mcp remove <name>
+```
+
+**Example:**
+
+```bash
+gemini mcp remove my-server
+```
+
+This will find and delete the "my-server" entry from the `mcpServers` object in the appropriate `settings.json` file based on the scope (`-s, --scope`).
diff --git a/packages/cli/src/commands/mcp.test.ts b/packages/cli/src/commands/mcp.test.ts
new file mode 100644
index 00000000..b4e9980c
--- /dev/null
+++ b/packages/cli/src/commands/mcp.test.ts
@@ -0,0 +1,55 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { describe, it, expect, vi } from 'vitest';
+import { mcpCommand } from './mcp.js';
+import { type Argv } from 'yargs';
+import yargs from 'yargs';
+
+describe('mcp command', () => {
+  it('should have correct command definition', () => {
+    expect(mcpCommand.command).toBe('mcp');
+    expect(mcpCommand.describe).toBe('Manage MCP servers');
+    expect(typeof mcpCommand.builder).toBe('function');
+    expect(typeof mcpCommand.handler).toBe('function');
+  });
+
+  it('should have exactly one option (help flag)', () => {
+    // Test to ensure that the global 'gemini' flags are not added to the mcp command
+    const yargsInstance = yargs();
+    const builtYargs = mcpCommand.builder(yargsInstance);
+    const options = builtYargs.getOptions();
+
+    // Should have exactly 1 option (help flag)
+    expect(Object.keys(options.key).length).toBe(1);
+    expect(options.key).toHaveProperty('help');
+  });
+
+  it('should register add, remove, and list subcommands', () => {
+    const mockYargs = {
+      command: vi.fn().mockReturnThis(),
+      demandCommand: vi.fn().mockReturnThis(),
+      version: vi.fn().mockReturnThis(),
+    };
+
+    mcpCommand.builder(mockYargs as unknown as Argv);
+
+    expect(mockYargs.command).toHaveBeenCalledTimes(3);
+
+    // Verify that the specific subcommands are registered
+    const commandCalls = mockYargs.command.mock.calls;
+    const commandNames = commandCalls.map((call) => call[0].command);
+
+    expect(commandNames).toContain('add <name> <commandOrUrl> [args...]');
+    expect(commandNames).toContain('remove <name>');
+    expect(commandNames).toContain('list');
+
+    expect(mockYargs.demandCommand).toHaveBeenCalledWith(
+      1,
+      'You need at least one command before continuing.',
+    );
+  });
+});
diff --git a/packages/cli/src/commands/mcp.ts b/packages/cli/src/commands/mcp.ts
new file mode 100644
index 00000000..5e55286c
--- /dev/null
+++ b/packages/cli/src/commands/mcp.ts
@@ -0,0 +1,27 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+// File for 'gemini mcp' command
+import type { CommandModule, Argv } from 'yargs';
+import { addCommand } from './mcp/add.js';
+import { removeCommand } from './mcp/remove.js';
+import { listCommand } from './mcp/list.js';
+
+export const mcpCommand: CommandModule = {
+  command: 'mcp',
+  describe: 'Manage MCP servers',
+  builder: (yargs: Argv) =>
+    yargs
+      .command(addCommand)
+      .command(removeCommand)
+      .command(listCommand)
+      .demandCommand(1, 'You need at least one command before continuing.')
+      .version(false),
+  handler: () => {
+    // yargs will automatically show help if no subcommand is provided
+    // thanks to demandCommand(1) in the builder.
+  },
+};
diff --git a/packages/cli/src/commands/mcp/add.test.ts b/packages/cli/src/commands/mcp/add.test.ts
new file mode 100644
index 00000000..1d431c48
--- /dev/null
+++ b/packages/cli/src/commands/mcp/add.test.ts
@@ -0,0 +1,88 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import yargs from 'yargs';
+import { addCommand } from './add.js';
+import { loadSettings, SettingScope } from '../../config/settings.js';
+
+vi.mock('fs/promises', () => ({
+  readFile: vi.fn(),
+  writeFile: vi.fn(),
+}));
+
+vi.mock('../../config/settings.js', async () => {
+  const actual = await vi.importActual('../../config/settings.js');
+  return {
+    ...actual,
+    loadSettings: vi.fn(),
+  };
+});
+
+const mockedLoadSettings = loadSettings as vi.Mock;
+
+describe('mcp add command', () => {
+  let parser: yargs.Argv;
+  let mockSetValue: vi.Mock;
+
+  beforeEach(() => {
+    vi.resetAllMocks();
+    const yargsInstance = yargs([]).command(addCommand);
+    parser = yargsInstance;
+    mockSetValue = vi.fn();
+    mockedLoadSettings.mockReturnValue({
+      forScope: () => ({ settings: {} }),
+      setValue: mockSetValue,
+    });
+  });
+
+  it('should add a stdio server to project settings', async () => {
+    await parser.parseAsync(
+      'add my-server /path/to/server arg1 arg2 -e FOO=bar',
+    );
+
+    expect(mockSetValue).toHaveBeenCalledWith(
+      SettingScope.Workspace,
+      'mcpServers',
+      {
+        'my-server': {
+          command: '/path/to/server',
+          args: ['arg1', 'arg2'],
+          env: { FOO: 'bar' },
+        },
+      },
+    );
+  });
+
+  it('should add an sse server to user settings', async () => {
+    await parser.parseAsync(
+      'add --transport sse sse-server https://example.com/sse-endpoint --scope user -H "X-API-Key: your-key"',
+    );
+
+    expect(mockSetValue).toHaveBeenCalledWith(SettingScope.User, 'mcpServers', {
+      'sse-server': {
+        url: 'https://example.com/sse-endpoint',
+        headers: { 'X-API-Key': 'your-key' },
+      },
+    });
+  });
+
+  it('should add an http server to project settings', async () => {
+    await parser.parseAsync(
+      'add --transport http http-server https://example.com/mcp -H "Authorization: Bearer your-token"',
+    );
+
+    expect(mockSetValue).toHaveBeenCalledWith(
+      SettingScope.Workspace,
+      'mcpServers',
+      {
+        'http-server': {
+          httpUrl: 'https://example.com/mcp',
+          headers: { Authorization: 'Bearer your-token' },
+        },
+      },
+    );
+  });
+});
diff --git a/packages/cli/src/commands/mcp/add.ts b/packages/cli/src/commands/mcp/add.ts
new file mode 100644
index 00000000..9537e131
--- /dev/null
+++ b/packages/cli/src/commands/mcp/add.ts
@@ -0,0 +1,211 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+// File for 'gemini mcp add' command
+import type { CommandModule } from 'yargs';
+import { loadSettings, SettingScope } from '../../config/settings.js';
+import { MCPServerConfig } from '@google/gemini-cli-core';
+
+async function addMcpServer(
+  name: string,
+  commandOrUrl: string,
+  args: Array<string | number> | undefined,
+  options: {
+    scope: string;
+    transport: string;
+    env: string[] | undefined;
+    header: string[] | undefined;
+    timeout?: number;
+    trust?: boolean;
+    description?: string;
+    includeTools?: string[];
+    excludeTools?: string[];
+  },
+) {
+  const {
+    scope,
+    transport,
+    env,
+    header,
+    timeout,
+    trust,
+    description,
+    includeTools,
+    excludeTools,
+  } = options;
+  const settingsScope =
+    scope === 'user' ? SettingScope.User : SettingScope.Workspace;
+  const settings = loadSettings(process.cwd());
+
+  let newServer: Partial<MCPServerConfig> = {};
+
+  const headers = header?.reduce(
+    (acc, curr) => {
+      const [key, ...valueParts] = curr.split(':');
+      const value = valueParts.join(':').trim();
+      if (key.trim() && value) {
+        acc[key.trim()] = value;
+      }
+      return acc;
+    },
+    {} as Record<string, string>,
+  );
+
+  switch (transport) {
+    case 'sse':
+      newServer = {
+        url: commandOrUrl,
+        headers,
+        timeout,
+        trust,
+        description,
+        includeTools,
+        excludeTools,
+      };
+      break;
+    case 'http':
+      newServer = {
+        httpUrl: commandOrUrl,
+        headers,
+        timeout,
+        trust,
+        description,
+        includeTools,
+        excludeTools,
+      };
+      break;
+    case 'stdio':
+    default:
+      newServer = {
+        command: commandOrUrl,
+        args: args?.map(String),
+        env: env?.reduce(
+          (acc, curr) => {
+            const [key, value] = curr.split('=');
+            if (key && value) {
+              acc[key] = value;
+            }
+            return acc;
+          },
+          {} as Record<string, string>,
+        ),
+        timeout,
+        trust,
+        description,
+        includeTools,
+        excludeTools,
+      };
+      break;
+  }
+
+  const existingSettings = settings.forScope(settingsScope).settings;
+  const mcpServers = existingSettings.mcpServers || {};
+
+  const isExistingServer = !!mcpServers[name];
+  if (isExistingServer) {
+    console.log(
+      `MCP server "${name}" is already configured within ${scope} settings.`,
+    );
+  }
+
+  mcpServers[name] = newServer as MCPServerConfig;
+
+  settings.setValue(settingsScope, 'mcpServers', mcpServers);
+
+  if (isExistingServer) {
+    console.log(`MCP server "${name}" updated in ${scope} settings.`);
+  } else {
+    console.log(
+      `MCP server "${name}" added to ${scope} settings. (${transport})`,
+    );
+  }
+}
+
+export const addCommand: CommandModule = {
+  command: 'add <name> <commandOrUrl> [args...]',
+  describe: 'Add a server',
+  builder: (yargs) =>
+    yargs
+      .usage('Usage: gemini mcp add [options] <name> <commandOrUrl> [args...]')
+      .positional('name', {
+        describe: 'Name of the server',
+        type: 'string',
+        demandOption: true,
+      })
+      .positional('commandOrUrl', {
+        describe: 'Command (stdio) or URL (sse, http)',
+        type: 'string',
+        demandOption: true,
+      })
+      .option('scope', {
+        alias: 's',
+        describe: 'Configuration scope (user or project)',
+        type: 'string',
+        default: 'project',
+        choices: ['user', 'project'],
+      })
+      .option('transport', {
+        alias: 't',
+        describe: 'Transport type (stdio, sse, http)',
+        type: 'string',
+        default: 'stdio',
+        choices: ['stdio', 'sse', 'http'],
+      })
+      .option('env', {
+        alias: 'e',
+        describe: 'Set environment variables (e.g. -e KEY=value)',
+        type: 'array',
+        string: true,
+      })
+      .option('header', {
+        alias: 'H',
+        describe:
+          'Set HTTP headers for SSE and HTTP transports (e.g. -H "X-Api-Key: abc123" -H "Authorization: Bearer abc123")',
+        type: 'array',
+        string: true,
+      })
+      .option('timeout', {
+        describe: 'Set connection timeout in milliseconds',
+        type: 'number',
+      })
+      .option('trust', {
+        describe:
+          'Trust the server (bypass all tool call confirmation prompts)',
+        type: 'boolean',
+      })
+      .option('description', {
+        describe: 'Set the description for the server',
+        type: 'string',
+      })
+      .option('include-tools', {
+        describe: 'A comma-separated list of tools to include',
+        type: 'array',
+        string: true,
+      })
+      .option('exclude-tools', {
+        describe: 'A comma-separated list of tools to exclude',
+        type: 'array',
+        string: true,
+      }),
+  handler: async (argv) => {
+    await addMcpServer(
+      argv.name as string,
+      argv.commandOrUrl as string,
+      argv.args as Array<string | number>,
+      {
+        scope: argv.scope as string,
+        transport: argv.transport as string,
+        env: argv.env as string[],
+        header: argv.header as string[],
+        timeout: argv.timeout as number | undefined,
+        trust: argv.trust as boolean | undefined,
+        description: argv.description as string | undefined,
+        includeTools: argv.includeTools as string[] | undefined,
+        excludeTools: argv.excludeTools as string[] | undefined,
+      },
+    );
+  },
+};
diff --git a/packages/cli/src/commands/mcp/list.test.ts b/packages/cli/src/commands/mcp/list.test.ts
new file mode 100644
index 00000000..daf2e3d7
--- /dev/null
+++ b/packages/cli/src/commands/mcp/list.test.ts
@@ -0,0 +1,154 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { vi, describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { listMcpServers } from './list.js';
+import { loadSettings } from '../../config/settings.js';
+import { loadExtensions } from '../../config/extension.js';
+import { createTransport } from '@google/gemini-cli-core';
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+
+vi.mock('../../config/settings.js');
+vi.mock('../../config/extension.js');
+vi.mock('@google/gemini-cli-core');
+vi.mock('@modelcontextprotocol/sdk/client/index.js');
+
+const mockedLoadSettings = loadSettings as vi.Mock;
+const mockedLoadExtensions = loadExtensions as vi.Mock;
+const mockedCreateTransport = createTransport as vi.Mock;
+const MockedClient = Client as vi.Mock;
+
+interface MockClient {
+  connect: vi.Mock;
+  ping: vi.Mock;
+  close: vi.Mock;
+}
+
+interface MockTransport {
+  close: vi.Mock;
+}
+
+describe('mcp list command', () => {
+  let consoleSpy: vi.SpyInstance;
+  let mockClient: MockClient;
+  let mockTransport: MockTransport;
+
+  beforeEach(() => {
+    vi.resetAllMocks();
+
+    consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+
+    mockTransport = { close: vi.fn() };
+    mockClient = {
+      connect: vi.fn(),
+      ping: vi.fn(),
+      close: vi.fn(),
+    };
+
+    MockedClient.mockImplementation(() => mockClient);
+    mockedCreateTransport.mockResolvedValue(mockTransport);
+    mockedLoadExtensions.mockReturnValue([]);
+  });
+
+  afterEach(() => {
+    consoleSpy.mockRestore();
+  });
+
+  it('should display message when no servers configured', async () => {
+    mockedLoadSettings.mockReturnValue({ merged: { mcpServers: {} } });
+
+    await listMcpServers();
+
+    expect(consoleSpy).toHaveBeenCalledWith('No MCP servers configured.');
+  });
+
+  it('should display different server types with connected status', async () => {
+    mockedLoadSettings.mockReturnValue({
+      merged: {
+        mcpServers: {
+          'stdio-server': { command: '/path/to/server', args: ['arg1'] },
+          'sse-server': { url: 'https://example.com/sse' },
+          'http-server': { httpUrl: 'https://example.com/http' },
+        },
+      },
+    });
+
+    mockClient.connect.mockResolvedValue(undefined);
+    mockClient.ping.mockResolvedValue(undefined);
+
+    await listMcpServers();
+
+    expect(consoleSpy).toHaveBeenCalledWith('Configured MCP servers:\n');
+    expect(consoleSpy).toHaveBeenCalledWith(
+      expect.stringContaining(
+        'stdio-server: /path/to/server arg1 (stdio) - Connected',
+      ),
+    );
+    expect(consoleSpy).toHaveBeenCalledWith(
+      expect.stringContaining(
+        'sse-server: https://example.com/sse (sse) - Connected',
+      ),
+    );
+    expect(consoleSpy).toHaveBeenCalledWith(
+      expect.stringContaining(
+        'http-server: https://example.com/http (http) - Connected',
+      ),
+    );
+  });
+
+  it('should display disconnected status when connection fails', async () => {
+    mockedLoadSettings.mockReturnValue({
+      merged: {
+        mcpServers: {
+          'test-server': { command: '/test/server' },
+        },
+      },
+    });
+
+    mockClient.connect.mockRejectedValue(new Error('Connection failed'));
+
+    await listMcpServers();
+
+    expect(consoleSpy).toHaveBeenCalledWith(
+      expect.stringContaining(
+        'test-server: /test/server  (stdio) - Disconnected',
+      ),
+    );
+  });
+
+  it('should merge extension servers with config servers', async () => {
+    mockedLoadSettings.mockReturnValue({
+      merged: {
+        mcpServers: { 'config-server': { command: '/config/server' } },
+      },
+    });
+
+    mockedLoadExtensions.mockReturnValue([
+      {
+        config: {
+          name: 'test-extension',
+          mcpServers: { 'extension-server': { command: '/ext/server' } },
+        },
+      },
+    ]);
+
+    mockClient.connect.mockResolvedValue(undefined);
+    mockClient.ping.mockResolvedValue(undefined);
+
+    await listMcpServers();
+
+    expect(consoleSpy).toHaveBeenCalledWith(
+      expect.stringContaining(
+        'config-server: /config/server  (stdio) - Connected',
+      ),
+    );
+    expect(consoleSpy).toHaveBeenCalledWith(
+      expect.stringContaining(
+        'extension-server: /ext/server  (stdio) - Connected',
+      ),
+    );
+  });
+});
diff --git a/packages/cli/src/commands/mcp/list.ts b/packages/cli/src/commands/mcp/list.ts
new file mode 100644
index 00000000..48ea912e
--- /dev/null
+++ b/packages/cli/src/commands/mcp/list.ts
@@ -0,0 +1,139 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+// File for 'gemini mcp list' command
+import type { CommandModule } from 'yargs';
+import { loadSettings } from '../../config/settings.js';
+import {
+  MCPServerConfig,
+  MCPServerStatus,
+  createTransport,
+} from '@google/gemini-cli-core';
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { loadExtensions } from '../../config/extension.js';
+
+const COLOR_GREEN = '\u001b[32m';
+const COLOR_YELLOW = '\u001b[33m';
+const COLOR_RED = '\u001b[31m';
+const RESET_COLOR = '\u001b[0m';
+
+async function getMcpServersFromConfig(): Promise<
+  Record<string, MCPServerConfig>
+> {
+  const settings = loadSettings(process.cwd());
+  const extensions = loadExtensions(process.cwd());
+  const mcpServers = { ...(settings.merged.mcpServers || {}) };
+  for (const extension of extensions) {
+    Object.entries(extension.config.mcpServers || {}).forEach(
+      ([key, server]) => {
+        if (mcpServers[key]) {
+          return;
+        }
+        mcpServers[key] = {
+          ...server,
+          extensionName: extension.config.name,
+        };
+      },
+    );
+  }
+  return mcpServers;
+}
+
+async function testMCPConnection(
+  serverName: string,
+  config: MCPServerConfig,
+): Promise<MCPServerStatus> {
+  const client = new Client({
+    name: 'mcp-test-client',
+    version: '0.0.1',
+  });
+
+  let transport;
+  try {
+    // Use the same transport creation logic as core
+    transport = await createTransport(serverName, config, false);
+  } catch (_error) {
+    await client.close();
+    return MCPServerStatus.DISCONNECTED;
+  }
+
+  try {
+    // Attempt actual MCP connection with short timeout
+    await client.connect(transport, { timeout: 5000 }); // 5s timeout
+
+    // Test basic MCP protocol by pinging the server
+    await client.ping();
+
+    await client.close();
+    return MCPServerStatus.CONNECTED;
+  } catch (_error) {
+    await transport.close();
+    return MCPServerStatus.DISCONNECTED;
+  }
+}
+
+async function getServerStatus(
+  serverName: string,
+  server: MCPServerConfig,
+): Promise<MCPServerStatus> {
+  // Test all server types by attempting actual connection
+  return await testMCPConnection(serverName, server);
+}
+
+export async function listMcpServers(): Promise<void> {
+  const mcpServers = await getMcpServersFromConfig();
+  const serverNames = Object.keys(mcpServers);
+
+  if (serverNames.length === 0) {
+    console.log('No MCP servers configured.');
+    return;
+  }
+
+  console.log('Configured MCP servers:\n');
+
+  for (const serverName of serverNames) {
+    const server = mcpServers[serverName];
+
+    const status = await getServerStatus(serverName, server);
+
+    let statusIndicator = '';
+    let statusText = '';
+    switch (status) {
+      case MCPServerStatus.CONNECTED:
+        statusIndicator = COLOR_GREEN + '✓' + RESET_COLOR;
+        statusText = 'Connected';
+        break;
+      case MCPServerStatus.CONNECTING:
+        statusIndicator = COLOR_YELLOW + '…' + RESET_COLOR;
+        statusText = 'Connecting';
+        break;
+      case MCPServerStatus.DISCONNECTED:
+      default:
+        statusIndicator = COLOR_RED + '✗' + RESET_COLOR;
+        statusText = 'Disconnected';
+        break;
+    }
+
+    let serverInfo = `${serverName}: `;
+    if (server.httpUrl) {
+      serverInfo += `${server.httpUrl} (http)`;
+    } else if (server.url) {
+      serverInfo += `${server.url} (sse)`;
+    } else if (server.command) {
+      serverInfo += `${server.command} ${server.args?.join(' ') || ''} (stdio)`;
+    }
+
+    console.log(`${statusIndicator} ${serverInfo} - ${statusText}`);
+  }
+}
+
+export const listCommand: CommandModule = {
+  command: 'list',
+  describe: 'List all configured MCP servers',
+  handler: async () => {
+    await listMcpServers();
+  },
+};
diff --git a/packages/cli/src/commands/mcp/remove.test.ts b/packages/cli/src/commands/mcp/remove.test.ts
new file mode 100644
index 00000000..eb7dedce
--- /dev/null
+++ b/packages/cli/src/commands/mcp/remove.test.ts
@@ -0,0 +1,69 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { vi, describe, it, expect, beforeEach } from 'vitest';
+import yargs from 'yargs';
+import { loadSettings, SettingScope } from '../../config/settings.js';
+import { removeCommand } from './remove.js';
+
+vi.mock('fs/promises', () => ({
+  readFile: vi.fn(),
+  writeFile: vi.fn(),
+}));
+
+vi.mock('../../config/settings.js', async () => {
+  const actual = await vi.importActual('../../config/settings.js');
+  return {
+    ...actual,
+    loadSettings: vi.fn(),
+  };
+});
+
+const mockedLoadSettings = loadSettings as vi.Mock;
+
+describe('mcp remove command', () => {
+  let parser: yargs.Argv;
+  let mockSetValue: vi.Mock;
+  let mockSettings: Record<string, unknown>;
+
+  beforeEach(() => {
+    vi.resetAllMocks();
+    const yargsInstance = yargs([]).command(removeCommand);
+    parser = yargsInstance;
+    mockSetValue = vi.fn();
+    mockSettings = {
+      mcpServers: {
+        'test-server': {
+          command: 'echo "hello"',
+        },
+      },
+    };
+    mockedLoadSettings.mockReturnValue({
+      forScope: () => ({ settings: mockSettings }),
+      setValue: mockSetValue,
+    });
+  });
+
+  it('should remove a server from project settings', async () => {
+    await parser.parseAsync('remove test-server');
+
+    expect(mockSetValue).toHaveBeenCalledWith(
+      SettingScope.Workspace,
+      'mcpServers',
+      {},
+    );
+  });
+
+  it('should show a message if server not found', async () => {
+    const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    await parser.parseAsync('remove non-existent-server');
+
+    expect(mockSetValue).not.toHaveBeenCalled();
+    expect(consoleSpy).toHaveBeenCalledWith(
+      'Server "non-existent-server" not found in project settings.',
+    );
+  });
+});
diff --git a/packages/cli/src/commands/mcp/remove.ts b/packages/cli/src/commands/mcp/remove.ts
new file mode 100644
index 00000000..80d66234
--- /dev/null
+++ b/packages/cli/src/commands/mcp/remove.ts
@@ -0,0 +1,60 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+// File for 'gemini mcp remove' command
+import type { CommandModule } from 'yargs';
+import { loadSettings, SettingScope } from '../../config/settings.js';
+
+async function removeMcpServer(
+  name: string,
+  options: {
+    scope: string;
+  },
+) {
+  const { scope } = options;
+  const settingsScope =
+    scope === 'user' ? SettingScope.User : SettingScope.Workspace;
+  const settings = loadSettings(process.cwd());
+
+  const existingSettings = settings.forScope(settingsScope).settings;
+  const mcpServers = existingSettings.mcpServers || {};
+
+  if (!mcpServers[name]) {
+    console.log(`Server "${name}" not found in ${scope} settings.`);
+    return;
+  }
+
+  delete mcpServers[name];
+
+  settings.setValue(settingsScope, 'mcpServers', mcpServers);
+
+  console.log(`Server "${name}" removed from ${scope} settings.`);
+}
+
+export const removeCommand: CommandModule = {
+  command: 'remove <name>',
+  describe: 'Remove a server',
+  builder: (yargs) =>
+    yargs
+      .usage('Usage: gemini mcp remove [options] <name>')
+      .positional('name', {
+        describe: 'Name of the server',
+        type: 'string',
+        demandOption: true,
+      })
+      .option('scope', {
+        alias: 's',
+        describe: 'Configuration scope (user or project)',
+        type: 'string',
+        default: 'project',
+        choices: ['user', 'project'],
+      }),
+  handler: async (argv) => {
+    await removeMcpServer(argv.name as string, {
+      scope: argv.scope as string,
+    });
+  },
+};
diff --git a/packages/cli/src/config/config.ts b/packages/cli/src/config/config.ts
index beba9602..7175c033 100644
--- a/packages/cli/src/config/config.ts
+++ b/packages/cli/src/config/config.ts
@@ -10,6 +10,7 @@ import { homedir } from 'node:os';
 import yargs from 'yargs/yargs';
 import { hideBin } from 'yargs/helpers';
 import process from 'node:process';
+import { mcpCommand } from '../commands/mcp.js';
 import {
   Config,
   loadServerHierarchicalMemory,
@@ -72,173 +73,185 @@ export async function parseArguments(): Promise<CliArgs> {
   const yargsInstance = yargs(hideBin(process.argv))
     .scriptName('gemini')
     .usage(
-      '$0 [options]',
-      'Gemini CLI - Launch an interactive CLI, use -p/--prompt for non-interactive mode',
+      'Usage: gemini [options] [command]\n\nGemini CLI - Launch an interactive CLI, use -p/--prompt for non-interactive mode',
     )
-    .option('model', {
-      alias: 'm',
-      type: 'string',
-      description: `Model`,
-      default: process.env.GEMINI_MODEL,
-    })
-    .option('prompt', {
-      alias: 'p',
-      type: 'string',
-      description: 'Prompt. Appended to input on stdin (if any).',
-    })
-    .option('prompt-interactive', {
-      alias: 'i',
-      type: 'string',
-      description:
-        'Execute the provided prompt and continue in interactive mode',
-    })
-    .option('sandbox', {
-      alias: 's',
-      type: 'boolean',
-      description: 'Run in sandbox?',
-    })
-    .option('sandbox-image', {
-      type: 'string',
-      description: 'Sandbox image URI.',
-    })
-    .option('debug', {
-      alias: 'd',
-      type: 'boolean',
-      description: 'Run in debug mode?',
-      default: false,
-    })
-    .option('all-files', {
-      alias: ['a'],
-      type: 'boolean',
-      description: 'Include ALL files in context?',
-      default: false,
-    })
-    .option('all_files', {
-      type: 'boolean',
-      description: 'Include ALL files in context?',
-      default: false,
-    })
-    .deprecateOption(
-      'all_files',
-      'Use --all-files instead. We will be removing --all_files in the coming weeks.',
+    .command('$0', 'Launch Gemini CLI', (yargsInstance) =>
+      yargsInstance
+        .option('model', {
+          alias: 'm',
+          type: 'string',
+          description: `Model`,
+          default: process.env.GEMINI_MODEL,
+        })
+        .option('prompt', {
+          alias: 'p',
+          type: 'string',
+          description: 'Prompt. Appended to input on stdin (if any).',
+        })
+        .option('prompt-interactive', {
+          alias: 'i',
+          type: 'string',
+          description:
+            'Execute the provided prompt and continue in interactive mode',
+        })
+        .option('sandbox', {
+          alias: 's',
+          type: 'boolean',
+          description: 'Run in sandbox?',
+        })
+        .option('sandbox-image', {
+          type: 'string',
+          description: 'Sandbox image URI.',
+        })
+        .option('debug', {
+          alias: 'd',
+          type: 'boolean',
+          description: 'Run in debug mode?',
+          default: false,
+        })
+        .option('all-files', {
+          alias: ['a'],
+          type: 'boolean',
+          description: 'Include ALL files in context?',
+          default: false,
+        })
+        .option('all_files', {
+          type: 'boolean',
+          description: 'Include ALL files in context?',
+          default: false,
+        })
+        .deprecateOption(
+          'all_files',
+          'Use --all-files instead. We will be removing --all_files in the coming weeks.',
+        )
+        .option('show-memory-usage', {
+          type: 'boolean',
+          description: 'Show memory usage in status bar',
+          default: false,
+        })
+        .option('show_memory_usage', {
+          type: 'boolean',
+          description: 'Show memory usage in status bar',
+          default: false,
+        })
+        .deprecateOption(
+          'show_memory_usage',
+          'Use --show-memory-usage instead. We will be removing --show_memory_usage in the coming weeks.',
+        )
+        .option('yolo', {
+          alias: 'y',
+          type: 'boolean',
+          description:
+            'Automatically accept all actions (aka YOLO mode, see https://www.youtube.com/watch?v=xvFZjo5PgG0 for more details)?',
+          default: false,
+        })
+        .option('telemetry', {
+          type: 'boolean',
+          description:
+            'Enable telemetry? This flag specifically controls if telemetry is sent. Other --telemetry-* flags set specific values but do not enable telemetry on their own.',
+        })
+        .option('telemetry-target', {
+          type: 'string',
+          choices: ['local', 'gcp'],
+          description:
+            'Set the telemetry target (local or gcp). Overrides settings files.',
+        })
+        .option('telemetry-otlp-endpoint', {
+          type: 'string',
+          description:
+            'Set the OTLP endpoint for telemetry. Overrides environment variables and settings files.',
+        })
+        .option('telemetry-log-prompts', {
+          type: 'boolean',
+          description:
+            'Enable or disable logging of user prompts for telemetry. Overrides settings files.',
+        })
+        .option('telemetry-outfile', {
+          type: 'string',
+          description: 'Redirect all telemetry output to the specified file.',
+        })
+        .option('checkpointing', {
+          alias: 'c',
+          type: 'boolean',
+          description: 'Enables checkpointing of file edits',
+          default: false,
+        })
+        .option('experimental-acp', {
+          type: 'boolean',
+          description: 'Starts the agent in ACP mode',
+        })
+        .option('allowed-mcp-server-names', {
+          type: 'array',
+          string: true,
+          description: 'Allowed MCP server names',
+        })
+        .option('extensions', {
+          alias: 'e',
+          type: 'array',
+          string: true,
+          description:
+            'A list of extensions to use. If not provided, all extensions are used.',
+        })
+        .option('list-extensions', {
+          alias: 'l',
+          type: 'boolean',
+          description: 'List all available extensions and exit.',
+        })
+        .option('ide-mode-feature', {
+          type: 'boolean',
+          description: 'Run in IDE mode?',
+        })
+        .option('proxy', {
+          type: 'string',
+          description:
+            'Proxy for gemini client, like schema://user:password@host:port',
+        })
+        .option('include-directories', {
+          type: 'array',
+          string: true,
+          description:
+            'Additional directories to include in the workspace (comma-separated or multiple --include-directories)',
+          coerce: (dirs: string[]) =>
+            // Handle comma-separated values
+            dirs.flatMap((dir) => dir.split(',').map((d) => d.trim())),
+        })
+        .option('load-memory-from-include-directories', {
+          type: 'boolean',
+          description:
+            'If true, when refreshing memory, GEMINI.md files should be loaded from all directories that are added. If false, GEMINI.md files should only be loaded from the primary working directory.',
+          default: false,
+        })
+        .check((argv) => {
+          if (argv.prompt && argv.promptInteractive) {
+            throw new Error(
+              'Cannot use both --prompt (-p) and --prompt-interactive (-i) together',
+            );
+          }
+          return true;
+        }),
     )
-    .option('show-memory-usage', {
-      type: 'boolean',
-      description: 'Show memory usage in status bar',
-      default: false,
-    })
-    .option('show_memory_usage', {
-      type: 'boolean',
-      description: 'Show memory usage in status bar',
-      default: false,
-    })
-    .deprecateOption(
-      'show_memory_usage',
-      'Use --show-memory-usage instead. We will be removing --show_memory_usage in the coming weeks.',
-    )
-    .option('yolo', {
-      alias: 'y',
-      type: 'boolean',
-      description:
-        'Automatically accept all actions (aka YOLO mode, see https://www.youtube.com/watch?v=xvFZjo5PgG0 for more details)?',
-      default: false,
-    })
-    .option('telemetry', {
-      type: 'boolean',
-      description:
-        'Enable telemetry? This flag specifically controls if telemetry is sent. Other --telemetry-* flags set specific values but do not enable telemetry on their own.',
-    })
-    .option('telemetry-target', {
-      type: 'string',
-      choices: ['local', 'gcp'],
-      description:
-        'Set the telemetry target (local or gcp). Overrides settings files.',
-    })
-    .option('telemetry-otlp-endpoint', {
-      type: 'string',
-      description:
-        'Set the OTLP endpoint for telemetry. Overrides environment variables and settings files.',
-    })
-    .option('telemetry-log-prompts', {
-      type: 'boolean',
-      description:
-        'Enable or disable logging of user prompts for telemetry. Overrides settings files.',
-    })
-    .option('telemetry-outfile', {
-      type: 'string',
-      description: 'Redirect all telemetry output to the specified file.',
-    })
-    .option('checkpointing', {
-      alias: 'c',
-      type: 'boolean',
-      description: 'Enables checkpointing of file edits',
-      default: false,
-    })
-    .option('experimental-acp', {
-      type: 'boolean',
-      description: 'Starts the agent in ACP mode',
-    })
-    .option('allowed-mcp-server-names', {
-      type: 'array',
-      string: true,
-      description: 'Allowed MCP server names',
-    })
-    .option('extensions', {
-      alias: 'e',
-      type: 'array',
-      string: true,
-      description:
-        'A list of extensions to use. If not provided, all extensions are used.',
-    })
-    .option('list-extensions', {
-      alias: 'l',
-      type: 'boolean',
-      description: 'List all available extensions and exit.',
-    })
-    .option('ide-mode-feature', {
-      type: 'boolean',
-      description: 'Run in IDE mode?',
-    })
-    .option('proxy', {
-      type: 'string',
-      description:
-        'Proxy for gemini client, like schema://user:password@host:port',
-    })
-    .option('include-directories', {
-      type: 'array',
-      string: true,
-      description:
-        'Additional directories to include in the workspace (comma-separated or multiple --include-directories)',
-      coerce: (dirs: string[]) =>
-        // Handle comma-separated values
-        dirs.flatMap((dir) => dir.split(',').map((d) => d.trim())),
-    })
-    .option('load-memory-from-include-directories', {
-      type: 'boolean',
-      description:
-        'If true, when refreshing memory, GEMINI.md files should be loaded from all directories that are added. If false, GEMINI.md files should only be loaded from the primary working directory.',
-      default: false,
-    })
+    // Register MCP subcommands
+    .command(mcpCommand)
     .version(await getCliVersion()) // This will enable the --version flag based on package.json
     .alias('v', 'version')
     .help()
     .alias('h', 'help')
     .strict()
-    .check((argv) => {
-      if (argv.prompt && argv.promptInteractive) {
-        throw new Error(
-          'Cannot use both --prompt (-p) and --prompt-interactive (-i) together',
-        );
-      }
-      return true;
-    });
+    .demandCommand(0, 0); // Allow base command to run with no subcommands
 
   yargsInstance.wrap(yargsInstance.terminalWidth());
-  const result = yargsInstance.parseSync();
+  const result = await yargsInstance.parse();
+
+  // Handle case where MCP subcommands are executed - they should exit the process
+  // and not return to main CLI logic
+  if (result._.length > 0 && result._[0] === 'mcp') {
+    // MCP commands handle their own execution and process exit
+    process.exit(0);
+  }
 
   // The import format is now only controlled by settings.memoryImportFormat
   // We no longer accept it as a CLI argument
-  return result as CliArgs;
+  return result as unknown as CliArgs;
 }
 
 // This function is now a thin wrapper around the server's implementation.

From 487818df276dc66827ce0f469f84bcae56a70801 Mon Sep 17 00:00:00 2001
From: Akhil Appana <akhil.appana@gmail.com>
Date: Wed, 6 Aug 2025 10:19:43 -0700
Subject: [PATCH 013/107] fix: improve error handling and path processing in
 memory discovery (#5175)

Co-authored-by: gemini-code-assist[bot] <176961590+gemini-code-assist[bot]@users.noreply.github.com>
Co-authored-by: Allen Hutchison <adh@google.com>
---
 packages/core/src/utils/memoryDiscovery.ts | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/packages/core/src/utils/memoryDiscovery.ts b/packages/core/src/utils/memoryDiscovery.ts
index f53d27a9..fcb1abdd 100644
--- a/packages/core/src/utils/memoryDiscovery.ts
+++ b/packages/core/src/utils/memoryDiscovery.ts
@@ -336,5 +336,8 @@ export async function loadServerHierarchicalMemory(
     logger.debug(
       `Combined instructions (snippet): ${combinedInstructions.substring(0, 500)}...`,
     );
-  return { memoryContent: combinedInstructions, fileCount: filePaths.length };
+  return {
+    memoryContent: combinedInstructions,
+    fileCount: contentsWithPaths.length,
+  };
 }

From fde9849d48e3b92377aca2eecfd390ebce288692 Mon Sep 17 00:00:00 2001
From: christine betts <chrstn@uw.edu>
Date: Wed, 6 Aug 2025 17:36:05 +0000
Subject: [PATCH 014/107] [ide-mode] Add support for in-IDE diff handling in
 the CLI (#5603)

Co-authored-by: gemini-code-assist[bot] <176961590+gemini-code-assist[bot]@users.noreply.github.com>
---
 .../messages/ToolConfirmationMessage.tsx      |  41 +++++--
 .../core/src/core/coreToolScheduler.test.ts   |   2 +
 packages/core/src/core/coreToolScheduler.ts   |  24 ++++
 packages/core/src/ide/ide-client.ts           | 106 +++++++++++++++++-
 packages/core/src/ide/ideContext.ts           |  59 ++++++++++
 packages/core/src/tools/edit.ts               |   1 +
 packages/core/src/tools/memoryTool.ts         |   1 +
 packages/core/src/tools/tools.ts              |   3 +
 packages/core/src/tools/write-file.test.ts    |  29 ++++-
 packages/core/src/tools/write-file.ts         |  18 +++
 .../vscode-ide-companion/src/diff-manager.ts  |  69 +++++++-----
 .../vscode-ide-companion/src/ide-server.ts    |  22 ++--
 12 files changed, 323 insertions(+), 52 deletions(-)

diff --git a/packages/cli/src/ui/components/messages/ToolConfirmationMessage.tsx b/packages/cli/src/ui/components/messages/ToolConfirmationMessage.tsx
index 197a922c..8b7f93d1 100644
--- a/packages/cli/src/ui/components/messages/ToolConfirmationMessage.tsx
+++ b/packages/cli/src/ui/components/messages/ToolConfirmationMessage.tsx
@@ -33,6 +33,7 @@ export const ToolConfirmationMessage: React.FC<
   ToolConfirmationMessageProps
 > = ({
   confirmationDetails,
+  config,
   isFocused = true,
   availableTerminalHeight,
   terminalWidth,
@@ -40,14 +41,29 @@ export const ToolConfirmationMessage: React.FC<
   const { onConfirm } = confirmationDetails;
   const childWidth = terminalWidth - 2; // 2 for padding
 
+  const handleConfirm = async (outcome: ToolConfirmationOutcome) => {
+    if (confirmationDetails.type === 'edit') {
+      const ideClient = config?.getIdeClient();
+      if (config?.getIdeMode() && config?.getIdeModeFeature()) {
+        const cliOutcome =
+          outcome === ToolConfirmationOutcome.Cancel ? 'rejected' : 'accepted';
+        await ideClient?.resolveDiffFromCli(
+          confirmationDetails.filePath,
+          cliOutcome,
+        );
+      }
+    }
+    onConfirm(outcome);
+  };
+
   useInput((_, key) => {
     if (!isFocused) return;
     if (key.escape) {
-      onConfirm(ToolConfirmationOutcome.Cancel);
+      handleConfirm(ToolConfirmationOutcome.Cancel);
     }
   });
 
-  const handleSelect = (item: ToolConfirmationOutcome) => onConfirm(item);
+  const handleSelect = (item: ToolConfirmationOutcome) => handleConfirm(item);
 
   let bodyContent: React.ReactNode | null = null; // Removed contextDisplay here
   let question: string;
@@ -85,6 +101,7 @@ export const ToolConfirmationMessage: React.FC<
       HEIGHT_OPTIONS;
     return Math.max(availableTerminalHeight - surroundingElementsHeight, 1);
   }
+
   if (confirmationDetails.type === 'edit') {
     if (confirmationDetails.isModifying) {
       return (
@@ -114,15 +131,25 @@ export const ToolConfirmationMessage: React.FC<
         label: 'Yes, allow always',
         value: ToolConfirmationOutcome.ProceedAlways,
       },
-      {
+    );
+    if (config?.getIdeMode() && config?.getIdeModeFeature()) {
+      options.push({
+        label: 'No',
+        value: ToolConfirmationOutcome.Cancel,
+      });
+    } else {
+      // TODO(chrstnb): support edit tool in IDE mode.
+
+      options.push({
         label: 'Modify with external editor',
         value: ToolConfirmationOutcome.ModifyWithEditor,
-      },
-      {
+      });
+      options.push({
         label: 'No, suggest changes (esc)',
         value: ToolConfirmationOutcome.Cancel,
-      },
-    );
+      });
+    }
+
     bodyContent = (
       <DiffRenderer
         diffContent={confirmationDetails.fileDiff}
diff --git a/packages/core/src/core/coreToolScheduler.test.ts b/packages/core/src/core/coreToolScheduler.test.ts
index 623fb436..4d786d00 100644
--- a/packages/core/src/core/coreToolScheduler.test.ts
+++ b/packages/core/src/core/coreToolScheduler.test.ts
@@ -92,6 +92,7 @@ class MockModifiableTool
         type: 'edit',
         title: 'Confirm Mock Tool',
         fileName: 'test.txt',
+        filePath: 'test.txt',
         fileDiff: 'diff',
         originalContent: 'originalContent',
         newContent: 'newContent',
@@ -434,6 +435,7 @@ describe('CoreToolScheduler edit cancellation', () => {
           type: 'edit',
           title: 'Confirm Edit',
           fileName: 'test.txt',
+          filePath: 'test.txt',
           fileDiff:
             '--- test.txt\n+++ test.txt\n@@ -1,1 +1,1 @@\n-old content\n+new content',
           originalContent: 'old content',
diff --git a/packages/core/src/core/coreToolScheduler.ts b/packages/core/src/core/coreToolScheduler.ts
index 5f2cc895..f54aa532 100644
--- a/packages/core/src/core/coreToolScheduler.ts
+++ b/packages/core/src/core/coreToolScheduler.ts
@@ -476,6 +476,30 @@ export class CoreToolScheduler {
           );
 
           if (confirmationDetails) {
+            // Allow IDE to resolve confirmation
+            if (
+              confirmationDetails.type === 'edit' &&
+              confirmationDetails.ideConfirmation
+            ) {
+              confirmationDetails.ideConfirmation.then((resolution) => {
+                if (resolution.status === 'accepted') {
+                  this.handleConfirmationResponse(
+                    reqInfo.callId,
+                    confirmationDetails.onConfirm,
+                    ToolConfirmationOutcome.ProceedOnce,
+                    signal,
+                  );
+                } else {
+                  this.handleConfirmationResponse(
+                    reqInfo.callId,
+                    confirmationDetails.onConfirm,
+                    ToolConfirmationOutcome.Cancel,
+                    signal,
+                  );
+                }
+              });
+            }
+
             const originalOnConfirm = confirmationDetails.onConfirm;
             const wrappedConfirmationDetails: ToolCallConfirmationDetails = {
               ...confirmationDetails,
diff --git a/packages/core/src/ide/ide-client.ts b/packages/core/src/ide/ide-client.ts
index 8f967147..42b79c44 100644
--- a/packages/core/src/ide/ide-client.ts
+++ b/packages/core/src/ide/ide-client.ts
@@ -9,7 +9,14 @@ import {
   DetectedIde,
   getIdeDisplayName,
 } from '../ide/detect-ide.js';
-import { ideContext, IdeContextNotificationSchema } from '../ide/ideContext.js';
+import {
+  ideContext,
+  IdeContextNotificationSchema,
+  IdeDiffAcceptedNotificationSchema,
+  IdeDiffClosedNotificationSchema,
+  CloseDiffResponseSchema,
+  DiffUpdateResult,
+} from '../ide/ideContext.js';
 import { Client } from '@modelcontextprotocol/sdk/client/index.js';
 import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
 
@@ -42,6 +49,7 @@ export class IdeClient {
   };
   private readonly currentIde: DetectedIde | undefined;
   private readonly currentIdeDisplayName: string | undefined;
+  private diffResponses = new Map<string, (result: DiffUpdateResult) => void>();
 
   private constructor() {
     this.currentIde = detectIde();
@@ -77,6 +85,75 @@ export class IdeClient {
     await this.establishConnection(port);
   }
 
+  /**
+   * A diff is accepted with any modifications if the user performs one of the
+   * following actions:
+   * - Clicks the checkbox icon in the IDE to accept
+   * - Runs `command+shift+p` > "Gemini CLI: Accept Diff in IDE" to accept
+   * - Selects "accept" in the CLI UI
+   * - Saves the file via `ctrl/command+s`
+   *
+   * A diff is rejected if the user performs one of the following actions:
+   * - Clicks the "x" icon in the IDE
+   * - Runs "Gemini CLI: Close Diff in IDE"
+   * - Selects "no" in the CLI UI
+   * - Closes the file
+   */
+  async openDiff(
+    filePath: string,
+    newContent?: string,
+  ): Promise<DiffUpdateResult> {
+    return new Promise<DiffUpdateResult>((resolve, reject) => {
+      this.diffResponses.set(filePath, resolve);
+      this.client
+        ?.callTool({
+          name: `openDiff`,
+          arguments: {
+            filePath,
+            newContent,
+          },
+        })
+        .catch((err) => {
+          logger.debug(`callTool for ${filePath} failed:`, err);
+          reject(err);
+        });
+    });
+  }
+
+  async closeDiff(filePath: string): Promise<string | undefined> {
+    try {
+      const result = await this.client?.callTool({
+        name: `closeDiff`,
+        arguments: {
+          filePath,
+        },
+      });
+
+      if (result) {
+        const parsed = CloseDiffResponseSchema.parse(result);
+        return parsed.content;
+      }
+    } catch (err) {
+      logger.debug(`callTool for ${filePath} failed:`, err);
+    }
+    return;
+  }
+
+  // Closes the diff. Instead of waiting for a notification,
+  // manually resolves the diff resolver as the desired outcome.
+  async resolveDiffFromCli(filePath: string, outcome: 'accepted' | 'rejected') {
+    const content = await this.closeDiff(filePath);
+    const resolver = this.diffResponses.get(filePath);
+    if (resolver) {
+      if (outcome === 'accepted') {
+        resolver({ status: 'accepted', content });
+      } else {
+        resolver({ status: 'rejected', content: undefined });
+      }
+      this.diffResponses.delete(filePath);
+    }
+  }
+
   disconnect() {
     this.setState(
       IDEConnectionStatus.Disconnected,
@@ -175,6 +252,33 @@ export class IdeClient {
         `IDE connection error. The connection was lost unexpectedly. Please try reconnecting by running /ide enable`,
       );
     };
+    this.client.setNotificationHandler(
+      IdeDiffAcceptedNotificationSchema,
+      (notification) => {
+        const { filePath, content } = notification.params;
+        const resolver = this.diffResponses.get(filePath);
+        if (resolver) {
+          resolver({ status: 'accepted', content });
+          this.diffResponses.delete(filePath);
+        } else {
+          logger.debug(`No resolver found for ${filePath}`);
+        }
+      },
+    );
+
+    this.client.setNotificationHandler(
+      IdeDiffClosedNotificationSchema,
+      (notification) => {
+        const { filePath } = notification.params;
+        const resolver = this.diffResponses.get(filePath);
+        if (resolver) {
+          resolver({ status: 'rejected', content: undefined });
+          this.diffResponses.delete(filePath);
+        } else {
+          logger.debug(`No resolver found for ${filePath}`);
+        }
+      },
+    );
   }
 
   private async establishConnection(port: string) {
diff --git a/packages/core/src/ide/ideContext.ts b/packages/core/src/ide/ideContext.ts
index 588e25ee..3052c029 100644
--- a/packages/core/src/ide/ideContext.ts
+++ b/packages/core/src/ide/ideContext.ts
@@ -36,10 +36,69 @@ export type IdeContext = z.infer<typeof IdeContextSchema>;
  * Zod schema for validating the 'ide/contextUpdate' notification from the IDE.
  */
 export const IdeContextNotificationSchema = z.object({
+  jsonrpc: z.literal('2.0'),
   method: z.literal('ide/contextUpdate'),
   params: IdeContextSchema,
 });
 
+export const IdeDiffAcceptedNotificationSchema = z.object({
+  jsonrpc: z.literal('2.0'),
+  method: z.literal('ide/diffAccepted'),
+  params: z.object({
+    filePath: z.string(),
+    content: z.string(),
+  }),
+});
+
+export const IdeDiffClosedNotificationSchema = z.object({
+  jsonrpc: z.literal('2.0'),
+  method: z.literal('ide/diffClosed'),
+  params: z.object({
+    filePath: z.string(),
+    content: z.string().optional(),
+  }),
+});
+
+export const CloseDiffResponseSchema = z
+  .object({
+    content: z
+      .array(
+        z.object({
+          text: z.string(),
+          type: z.literal('text'),
+        }),
+      )
+      .min(1),
+  })
+  .transform((val, ctx) => {
+    try {
+      const parsed = JSON.parse(val.content[0].text);
+      const innerSchema = z.object({ content: z.string().optional() });
+      const validationResult = innerSchema.safeParse(parsed);
+      if (!validationResult.success) {
+        validationResult.error.issues.forEach((issue) => ctx.addIssue(issue));
+        return z.NEVER;
+      }
+      return validationResult.data;
+    } catch (_) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: 'Invalid JSON in text content',
+      });
+      return z.NEVER;
+    }
+  });
+
+export type DiffUpdateResult =
+  | {
+      status: 'accepted';
+      content?: string;
+    }
+  | {
+      status: 'rejected';
+      content: undefined;
+    };
+
 type IdeContextSubscriber = (ideContext: IdeContext | undefined) => void;
 
 /**
diff --git a/packages/core/src/tools/edit.ts b/packages/core/src/tools/edit.ts
index 25da2292..0d129e42 100644
--- a/packages/core/src/tools/edit.ts
+++ b/packages/core/src/tools/edit.ts
@@ -332,6 +332,7 @@ Expectation for required parameters:
       type: 'edit',
       title: `Confirm Edit: ${shortenPath(makeRelative(params.file_path, this.config.getTargetDir()))}`,
       fileName,
+      filePath: params.file_path,
       fileDiff,
       originalContent: editData.currentContent,
       newContent: editData.newContent,
diff --git a/packages/core/src/tools/memoryTool.ts b/packages/core/src/tools/memoryTool.ts
index 96509f79..847ea5cf 100644
--- a/packages/core/src/tools/memoryTool.ts
+++ b/packages/core/src/tools/memoryTool.ts
@@ -220,6 +220,7 @@ export class MemoryTool
       type: 'edit',
       title: `Confirm Memory Save: ${tildeifyPath(memoryFilePath)}`,
       fileName: memoryFilePath,
+      filePath: memoryFilePath,
       fileDiff,
       originalContent: currentContent,
       newContent,
diff --git a/packages/core/src/tools/tools.ts b/packages/core/src/tools/tools.ts
index 5d9d9253..3404093f 100644
--- a/packages/core/src/tools/tools.ts
+++ b/packages/core/src/tools/tools.ts
@@ -6,6 +6,7 @@
 
 import { FunctionDeclaration, PartListUnion, Schema } from '@google/genai';
 import { ToolErrorType } from './tool-error.js';
+import { DiffUpdateResult } from '../ide/ideContext.js';
 
 /**
  * Interface representing the base Tool functionality
@@ -330,10 +331,12 @@ export interface ToolEditConfirmationDetails {
     payload?: ToolConfirmationPayload,
   ) => Promise<void>;
   fileName: string;
+  filePath: string;
   fileDiff: string;
   originalContent: string | null;
   newContent: string;
   isModifying?: boolean;
+  ideConfirmation?: Promise<DiffUpdateResult>;
 }
 
 export interface ToolConfirmationPayload {
diff --git a/packages/core/src/tools/write-file.test.ts b/packages/core/src/tools/write-file.test.ts
index fe662a02..563579bb 100644
--- a/packages/core/src/tools/write-file.test.ts
+++ b/packages/core/src/tools/write-file.test.ts
@@ -55,6 +55,9 @@ const mockConfigInternal = {
   getApprovalMode: vi.fn(() => ApprovalMode.DEFAULT),
   setApprovalMode: vi.fn(),
   getGeminiClient: vi.fn(), // Initialize as a plain mock function
+  getIdeClient: vi.fn(),
+  getIdeMode: vi.fn(() => false),
+  getIdeModeFeature: vi.fn(() => false),
   getWorkspaceContext: () => createMockWorkspaceContext(rootDir),
   getApiKey: () => 'test-key',
   getModel: () => 'test-model',
@@ -110,6 +113,14 @@ describe('WriteFileTool', () => {
     mockConfigInternal.getGeminiClient.mockReturnValue(
       mockGeminiClientInstance,
     );
+    mockConfigInternal.getIdeClient.mockReturnValue({
+      openDiff: vi.fn(),
+      closeDiff: vi.fn(),
+      getIdeContext: vi.fn(),
+      subscribeToIdeContext: vi.fn(),
+      isCodeTrackerEnabled: vi.fn(),
+      getTrackedCode: vi.fn(),
+    });
 
     tool = new WriteFileTool(mockConfig);
 
@@ -500,7 +511,11 @@ describe('WriteFileTool', () => {
         params,
         abortSignal,
       );
-      if (typeof confirmDetails === 'object' && confirmDetails.onConfirm) {
+      if (
+        typeof confirmDetails === 'object' &&
+        'onConfirm' in confirmDetails &&
+        confirmDetails.onConfirm
+      ) {
         await confirmDetails.onConfirm(ToolConfirmationOutcome.ProceedOnce);
       }
 
@@ -554,7 +569,11 @@ describe('WriteFileTool', () => {
         params,
         abortSignal,
       );
-      if (typeof confirmDetails === 'object' && confirmDetails.onConfirm) {
+      if (
+        typeof confirmDetails === 'object' &&
+        'onConfirm' in confirmDetails &&
+        confirmDetails.onConfirm
+      ) {
         await confirmDetails.onConfirm(ToolConfirmationOutcome.ProceedOnce);
       }
 
@@ -595,7 +614,11 @@ describe('WriteFileTool', () => {
         params,
         abortSignal,
       );
-      if (typeof confirmDetails === 'object' && confirmDetails.onConfirm) {
+      if (
+        typeof confirmDetails === 'object' &&
+        'onConfirm' in confirmDetails &&
+        confirmDetails.onConfirm
+      ) {
         await confirmDetails.onConfirm(ToolConfirmationOutcome.ProceedOnce);
       }
 
diff --git a/packages/core/src/tools/write-file.ts b/packages/core/src/tools/write-file.ts
index 1cb1a917..32ecc068 100644
--- a/packages/core/src/tools/write-file.ts
+++ b/packages/core/src/tools/write-file.ts
@@ -32,6 +32,7 @@ import {
   recordFileOperationMetric,
   FileOperation,
 } from '../telemetry/metrics.js';
+import { IDEConnectionStatus } from '../ide/ide-client.js';
 
 /**
  * Parameters for the WriteFile tool
@@ -184,10 +185,19 @@ export class WriteFileTool
       DEFAULT_DIFF_OPTIONS,
     );
 
+    const ideClient = this.config.getIdeClient();
+    const ideConfirmation =
+      this.config.getIdeModeFeature() &&
+      this.config.getIdeMode() &&
+      ideClient.getConnectionStatus().status === IDEConnectionStatus.Connected
+        ? ideClient.openDiff(params.file_path, correctedContent)
+        : undefined;
+
     const confirmationDetails: ToolEditConfirmationDetails = {
       type: 'edit',
       title: `Confirm Write: ${shortenPath(relativePath)}`,
       fileName,
+      filePath: params.file_path,
       fileDiff,
       originalContent,
       newContent: correctedContent,
@@ -195,7 +205,15 @@ export class WriteFileTool
         if (outcome === ToolConfirmationOutcome.ProceedAlways) {
           this.config.setApprovalMode(ApprovalMode.AUTO_EDIT);
         }
+
+        if (ideConfirmation) {
+          const result = await ideConfirmation;
+          if (result.status === 'accepted' && result.content) {
+            params.content = result.content;
+          }
+        }
       },
+      ideConfirmation,
     };
     return confirmationDetails;
   }
diff --git a/packages/vscode-ide-companion/src/diff-manager.ts b/packages/vscode-ide-companion/src/diff-manager.ts
index 159a6101..0dad03a6 100644
--- a/packages/vscode-ide-companion/src/diff-manager.ts
+++ b/packages/vscode-ide-companion/src/diff-manager.ts
@@ -4,10 +4,14 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import * as vscode from 'vscode';
-import * as path from 'node:path';
-import { DIFF_SCHEME } from './extension.js';
+import {
+  IdeDiffAcceptedNotificationSchema,
+  IdeDiffClosedNotificationSchema,
+} from '@google/gemini-cli-core';
 import { type JSONRPCNotification } from '@modelcontextprotocol/sdk/types.js';
+import * as path from 'node:path';
+import * as vscode from 'vscode';
+import { DIFF_SCHEME } from './extension.js';
 
 export class DiffContentProvider implements vscode.TextDocumentContentProvider {
   private content = new Map<string, string>();
@@ -126,18 +130,19 @@ export class DiffManager {
       const rightDoc = await vscode.workspace.openTextDocument(uriToClose);
       const modifiedContent = rightDoc.getText();
       await this.closeDiffEditor(uriToClose);
-      this.onDidChangeEmitter.fire({
-        jsonrpc: '2.0',
-        method: 'ide/diffClosed',
-        params: {
-          filePath,
-          content: modifiedContent,
-        },
-      });
-      vscode.window.showInformationMessage(`Diff for ${filePath} closed.`);
-    } else {
-      vscode.window.showWarningMessage(`No open diff found for ${filePath}.`);
+      this.onDidChangeEmitter.fire(
+        IdeDiffClosedNotificationSchema.parse({
+          jsonrpc: '2.0',
+          method: 'ide/diffClosed',
+          params: {
+            filePath,
+            content: modifiedContent,
+          },
+        }),
+      );
+      return modifiedContent;
     }
+    return;
   }
 
   /**
@@ -156,14 +161,16 @@ export class DiffManager {
     const modifiedContent = rightDoc.getText();
     await this.closeDiffEditor(rightDocUri);
 
-    this.onDidChangeEmitter.fire({
-      jsonrpc: '2.0',
-      method: 'ide/diffAccepted',
-      params: {
-        filePath: diffInfo.originalFilePath,
-        content: modifiedContent,
-      },
-    });
+    this.onDidChangeEmitter.fire(
+      IdeDiffAcceptedNotificationSchema.parse({
+        jsonrpc: '2.0',
+        method: 'ide/diffAccepted',
+        params: {
+          filePath: diffInfo.originalFilePath,
+          content: modifiedContent,
+        },
+      }),
+    );
   }
 
   /**
@@ -184,14 +191,16 @@ export class DiffManager {
     const modifiedContent = rightDoc.getText();
     await this.closeDiffEditor(rightDocUri);
 
-    this.onDidChangeEmitter.fire({
-      jsonrpc: '2.0',
-      method: 'ide/diffClosed',
-      params: {
-        filePath: diffInfo.originalFilePath,
-        content: modifiedContent,
-      },
-    });
+    this.onDidChangeEmitter.fire(
+      IdeDiffClosedNotificationSchema.parse({
+        jsonrpc: '2.0',
+        method: 'ide/diffClosed',
+        params: {
+          filePath: diffInfo.originalFilePath,
+          content: modifiedContent,
+        },
+      }),
+    );
   }
 
   private addDiffDocument(uri: vscode.Uri, diffInfo: DiffInfo) {
diff --git a/packages/vscode-ide-companion/src/ide-server.ts b/packages/vscode-ide-companion/src/ide-server.ts
index 30215ccc..eec99cb3 100644
--- a/packages/vscode-ide-companion/src/ide-server.ts
+++ b/packages/vscode-ide-companion/src/ide-server.ts
@@ -5,15 +5,13 @@
  */
 
 import * as vscode from 'vscode';
+import { IdeContextNotificationSchema } from '@google/gemini-cli-core';
+import { isInitializeRequest } from '@modelcontextprotocol/sdk/types.js';
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
-import express, { Request, Response } from 'express';
+import express, { type Request, type Response } from 'express';
 import { randomUUID } from 'node:crypto';
-import {
-  isInitializeRequest,
-  type JSONRPCNotification,
-} from '@modelcontextprotocol/sdk/types.js';
-import { Server as HTTPServer } from 'node:http';
+import { type Server as HTTPServer } from 'node:http';
 import { z } from 'zod';
 import { DiffManager } from './diff-manager.js';
 import { OpenFilesManager } from './open-files-manager.js';
@@ -28,11 +26,12 @@ function sendIdeContextUpdateNotification(
 ) {
   const ideContext = openFilesManager.state;
 
-  const notification: JSONRPCNotification = {
+  const notification = IdeContextNotificationSchema.parse({
     jsonrpc: '2.0',
     method: 'ide/contextUpdate',
     params: ideContext,
-  };
+  });
+
   log(
     `Sending IDE context update notification: ${JSON.stringify(
       notification,
@@ -76,7 +75,7 @@ export class IDEServer {
     });
     context.subscriptions.push(onDidChangeSubscription);
     const onDidChangeDiffSubscription = this.diffManager.onDidChange(
-      (notification: JSONRPCNotification) => {
+      (notification) => {
         for (const transport of Object.values(transports)) {
           transport.send(notification);
         }
@@ -269,12 +268,13 @@ const createMcpServer = (diffManager: DiffManager) => {
       }).shape,
     },
     async ({ filePath }: { filePath: string }) => {
-      await diffManager.closeDiff(filePath);
+      const content = await diffManager.closeDiff(filePath);
+      const response = { content: content ?? undefined };
       return {
         content: [
           {
             type: 'text',
-            text: `Closed diff for ${filePath}`,
+            text: JSON.stringify(response),
           },
         ],
       };

From 882a97aff998b2f19731e9966d135f1db5a59914 Mon Sep 17 00:00:00 2001
From: agarwalravikant <agarwalravikant@gmail.com>
Date: Wed, 6 Aug 2025 23:16:42 +0530
Subject: [PATCH 015/107] =?UTF-8?q?Fix=20to=20send=20user=20tool=20confirm?=
 =?UTF-8?q?ation=20decision=20for=20yolo=20or=20non=20interacti=E2=80=A6?=
 =?UTF-8?q?=20(#5677)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Co-authored-by: Ravikant Agarwal <ravikantag@google.com>
---
 packages/core/src/core/coreToolScheduler.ts   | 26 ++++++++++++++-----
 .../src/core/nonInteractiveToolExecutor.ts    |  2 ++
 packages/core/src/telemetry/metrics.ts        |  2 +-
 packages/core/src/telemetry/types.ts          |  4 ++-
 .../core/src/telemetry/uiTelemetry.test.ts    |  6 +++++
 packages/core/src/telemetry/uiTelemetry.ts    |  4 +++
 6 files changed, 35 insertions(+), 9 deletions(-)

diff --git a/packages/core/src/core/coreToolScheduler.ts b/packages/core/src/core/coreToolScheduler.ts
index f54aa532..9b999b6b 100644
--- a/packages/core/src/core/coreToolScheduler.ts
+++ b/packages/core/src/core/coreToolScheduler.ts
@@ -468,6 +468,10 @@ export class CoreToolScheduler {
       const { request: reqInfo, tool: toolInstance } = toolCall;
       try {
         if (this.config.getApprovalMode() === ApprovalMode.YOLO) {
+          this.setToolCallOutcome(
+            reqInfo.callId,
+            ToolConfirmationOutcome.ProceedAlways,
+          );
           this.setStatusInternal(reqInfo.callId, 'scheduled');
         } else {
           const confirmationDetails = await toolInstance.shouldConfirmExecute(
@@ -521,6 +525,10 @@ export class CoreToolScheduler {
               wrappedConfirmationDetails,
             );
           } else {
+            this.setToolCallOutcome(
+              reqInfo.callId,
+              ToolConfirmationOutcome.ProceedAlways,
+            );
             this.setStatusInternal(reqInfo.callId, 'scheduled');
           }
         }
@@ -555,13 +563,7 @@ export class CoreToolScheduler {
       await originalOnConfirm(outcome);
     }
 
-    this.toolCalls = this.toolCalls.map((call) => {
-      if (call.request.callId !== callId) return call;
-      return {
-        ...call,
-        outcome,
-      };
-    });
+    this.setToolCallOutcome(callId, outcome);
 
     if (outcome === ToolConfirmationOutcome.Cancel || signal.aborted) {
       this.setStatusInternal(
@@ -774,4 +776,14 @@ export class CoreToolScheduler {
       this.onToolCallsUpdate([...this.toolCalls]);
     }
   }
+
+  private setToolCallOutcome(callId: string, outcome: ToolConfirmationOutcome) {
+    this.toolCalls = this.toolCalls.map((call) => {
+      if (call.request.callId !== callId) return call;
+      return {
+        ...call,
+        outcome,
+      };
+    });
+  }
 }
diff --git a/packages/core/src/core/nonInteractiveToolExecutor.ts b/packages/core/src/core/nonInteractiveToolExecutor.ts
index 52704bf1..ed235cd3 100644
--- a/packages/core/src/core/nonInteractiveToolExecutor.ts
+++ b/packages/core/src/core/nonInteractiveToolExecutor.ts
@@ -14,6 +14,7 @@ import {
 } from '../index.js';
 import { Config } from '../config/config.js';
 import { convertToFunctionResponse } from './coreToolScheduler.js';
+import { ToolCallDecision } from '../telemetry/types.js';
 
 /**
  * Executes a single tool call non-interactively.
@@ -87,6 +88,7 @@ export async function executeToolCall(
       error_type:
         toolResult.error === undefined ? undefined : toolResult.error.type,
       prompt_id: toolCallRequest.prompt_id,
+      decision: ToolCallDecision.AUTO_ACCEPT,
     });
 
     const response = convertToFunctionResponse(
diff --git a/packages/core/src/telemetry/metrics.ts b/packages/core/src/telemetry/metrics.ts
index 124bc602..103f7f71 100644
--- a/packages/core/src/telemetry/metrics.ts
+++ b/packages/core/src/telemetry/metrics.ts
@@ -100,7 +100,7 @@ export function recordToolCallMetrics(
   functionName: string,
   durationMs: number,
   success: boolean,
-  decision?: 'accept' | 'reject' | 'modify',
+  decision?: 'accept' | 'reject' | 'modify' | 'auto_accept',
 ): void {
   if (!toolCallCounter || !toolCallLatencyHistogram || !isMetricsInitialized)
     return;
diff --git a/packages/core/src/telemetry/types.ts b/packages/core/src/telemetry/types.ts
index 668421f0..db84e2da 100644
--- a/packages/core/src/telemetry/types.ts
+++ b/packages/core/src/telemetry/types.ts
@@ -14,6 +14,7 @@ export enum ToolCallDecision {
   ACCEPT = 'accept',
   REJECT = 'reject',
   MODIFY = 'modify',
+  AUTO_ACCEPT = 'auto_accept',
 }
 
 export function getDecisionFromOutcome(
@@ -21,10 +22,11 @@ export function getDecisionFromOutcome(
 ): ToolCallDecision {
   switch (outcome) {
     case ToolConfirmationOutcome.ProceedOnce:
+      return ToolCallDecision.ACCEPT;
     case ToolConfirmationOutcome.ProceedAlways:
     case ToolConfirmationOutcome.ProceedAlwaysServer:
     case ToolConfirmationOutcome.ProceedAlwaysTool:
-      return ToolCallDecision.ACCEPT;
+      return ToolCallDecision.AUTO_ACCEPT;
     case ToolConfirmationOutcome.ModifyWithEditor:
       return ToolCallDecision.MODIFY;
     case ToolConfirmationOutcome.Cancel:
diff --git a/packages/core/src/telemetry/uiTelemetry.test.ts b/packages/core/src/telemetry/uiTelemetry.test.ts
index bce54ad8..221804d2 100644
--- a/packages/core/src/telemetry/uiTelemetry.test.ts
+++ b/packages/core/src/telemetry/uiTelemetry.test.ts
@@ -104,6 +104,7 @@ describe('UiTelemetryService', () => {
           [ToolCallDecision.ACCEPT]: 0,
           [ToolCallDecision.REJECT]: 0,
           [ToolCallDecision.MODIFY]: 0,
+          [ToolCallDecision.AUTO_ACCEPT]: 0,
         },
         byName: {},
       },
@@ -362,6 +363,7 @@ describe('UiTelemetryService', () => {
           [ToolCallDecision.ACCEPT]: 1,
           [ToolCallDecision.REJECT]: 0,
           [ToolCallDecision.MODIFY]: 0,
+          [ToolCallDecision.AUTO_ACCEPT]: 0,
         },
       });
     });
@@ -395,6 +397,7 @@ describe('UiTelemetryService', () => {
           [ToolCallDecision.ACCEPT]: 0,
           [ToolCallDecision.REJECT]: 1,
           [ToolCallDecision.MODIFY]: 0,
+          [ToolCallDecision.AUTO_ACCEPT]: 0,
         },
       });
     });
@@ -434,11 +437,13 @@ describe('UiTelemetryService', () => {
         [ToolCallDecision.ACCEPT]: 0,
         [ToolCallDecision.REJECT]: 0,
         [ToolCallDecision.MODIFY]: 0,
+        [ToolCallDecision.AUTO_ACCEPT]: 0,
       });
       expect(tools.byName['test_tool'].decisions).toEqual({
         [ToolCallDecision.ACCEPT]: 0,
         [ToolCallDecision.REJECT]: 0,
         [ToolCallDecision.MODIFY]: 0,
+        [ToolCallDecision.AUTO_ACCEPT]: 0,
       });
     });
 
@@ -483,6 +488,7 @@ describe('UiTelemetryService', () => {
           [ToolCallDecision.ACCEPT]: 1,
           [ToolCallDecision.REJECT]: 1,
           [ToolCallDecision.MODIFY]: 0,
+          [ToolCallDecision.AUTO_ACCEPT]: 0,
         },
       });
     });
diff --git a/packages/core/src/telemetry/uiTelemetry.ts b/packages/core/src/telemetry/uiTelemetry.ts
index 2713ac65..fbf5b8dc 100644
--- a/packages/core/src/telemetry/uiTelemetry.ts
+++ b/packages/core/src/telemetry/uiTelemetry.ts
@@ -32,6 +32,7 @@ export interface ToolCallStats {
     [ToolCallDecision.ACCEPT]: number;
     [ToolCallDecision.REJECT]: number;
     [ToolCallDecision.MODIFY]: number;
+    [ToolCallDecision.AUTO_ACCEPT]: number;
   };
 }
 
@@ -62,6 +63,7 @@ export interface SessionMetrics {
       [ToolCallDecision.ACCEPT]: number;
       [ToolCallDecision.REJECT]: number;
       [ToolCallDecision.MODIFY]: number;
+      [ToolCallDecision.AUTO_ACCEPT]: number;
     };
     byName: Record<string, ToolCallStats>;
   };
@@ -94,6 +96,7 @@ const createInitialMetrics = (): SessionMetrics => ({
       [ToolCallDecision.ACCEPT]: 0,
       [ToolCallDecision.REJECT]: 0,
       [ToolCallDecision.MODIFY]: 0,
+      [ToolCallDecision.AUTO_ACCEPT]: 0,
     },
     byName: {},
   },
@@ -192,6 +195,7 @@ export class UiTelemetryService extends EventEmitter {
           [ToolCallDecision.ACCEPT]: 0,
           [ToolCallDecision.REJECT]: 0,
           [ToolCallDecision.MODIFY]: 0,
+          [ToolCallDecision.AUTO_ACCEPT]: 0,
         },
       };
     }

From 6133bea388a2de69c71a6be6f1450707f2ce4dfb Mon Sep 17 00:00:00 2001
From: joshualitt <joshualitt@google.com>
Date: Wed, 6 Aug 2025 10:50:02 -0700
Subject: [PATCH 016/107] feat(core): Introduce `DeclarativeTool` and
 `ToolInvocation`. (#5613)

---
 packages/cli/src/acp/acpPeer.ts               | 159 ++++----
 .../cli/src/ui/hooks/atCommandProcessor.ts    |  13 +-
 .../cli/src/ui/hooks/useGeminiStream.test.tsx |  56 ++-
 .../cli/src/ui/hooks/useReactToolScheduler.ts |  27 +-
 .../cli/src/ui/hooks/useToolScheduler.test.ts | 180 +++++-----
 packages/core/src/core/client.ts              |  18 +-
 .../core/src/core/coreToolScheduler.test.ts   |  83 ++---
 packages/core/src/core/coreToolScheduler.ts   | 110 +++++-
 .../core/nonInteractiveToolExecutor.test.ts   |  81 ++---
 .../src/core/nonInteractiveToolExecutor.ts    |   2 +-
 .../src/telemetry/loggers.test.circular.ts    |  10 +-
 packages/core/src/telemetry/loggers.test.ts   |   7 +-
 .../core/src/telemetry/uiTelemetry.test.ts    |   8 +-
 packages/core/src/test-utils/tools.ts         |  63 ++++
 packages/core/src/tools/edit.ts               |   4 +-
 packages/core/src/tools/memoryTool.ts         |   4 +-
 .../core/src/tools/modifiable-tool.test.ts    |  12 +-
 packages/core/src/tools/modifiable-tool.ts    |  18 +-
 packages/core/src/tools/read-file.test.ts     | 338 +++++++++---------
 packages/core/src/tools/read-file.ts          | 138 +++----
 packages/core/src/tools/tool-registry.test.ts |  24 +-
 packages/core/src/tools/tool-registry.ts      |  14 +-
 packages/core/src/tools/tools.ts              | 299 ++++++++++++----
 packages/core/src/tools/write-file.ts         |   4 +-
 24 files changed, 991 insertions(+), 681 deletions(-)
 create mode 100644 packages/core/src/test-utils/tools.ts

diff --git a/packages/cli/src/acp/acpPeer.ts b/packages/cli/src/acp/acpPeer.ts
index 90952b7f..40d8753f 100644
--- a/packages/cli/src/acp/acpPeer.ts
+++ b/packages/cli/src/acp/acpPeer.ts
@@ -239,65 +239,62 @@ class GeminiAgent implements Agent {
       );
     }
 
-    let toolCallId;
-    const confirmationDetails = await tool.shouldConfirmExecute(
-      args,
-      abortSignal,
-    );
-    if (confirmationDetails) {
-      let content: acp.ToolCallContent | null = null;
-      if (confirmationDetails.type === 'edit') {
-        content = {
-          type: 'diff',
-          path: confirmationDetails.fileName,
-          oldText: confirmationDetails.originalContent,
-          newText: confirmationDetails.newContent,
-        };
-      }
-
-      const result = await this.client.requestToolCallConfirmation({
-        label: tool.getDescription(args),
-        icon: tool.icon,
-        content,
-        confirmation: toAcpToolCallConfirmation(confirmationDetails),
-        locations: tool.toolLocations(args),
-      });
-
-      await confirmationDetails.onConfirm(toToolCallOutcome(result.outcome));
-      switch (result.outcome) {
-        case 'reject':
-          return errorResponse(
-            new Error(`Tool "${fc.name}" not allowed to run by the user.`),
-          );
-
-        case 'cancel':
-          return errorResponse(
-            new Error(`Tool "${fc.name}" was canceled by the user.`),
-          );
-        case 'allow':
-        case 'alwaysAllow':
-        case 'alwaysAllowMcpServer':
-        case 'alwaysAllowTool':
-          break;
-        default: {
-          const resultOutcome: never = result.outcome;
-          throw new Error(`Unexpected: ${resultOutcome}`);
-        }
-      }
-
-      toolCallId = result.id;
-    } else {
-      const result = await this.client.pushToolCall({
-        icon: tool.icon,
-        label: tool.getDescription(args),
-        locations: tool.toolLocations(args),
-      });
-
-      toolCallId = result.id;
-    }
-
+    let toolCallId: number | undefined = undefined;
     try {
-      const toolResult: ToolResult = await tool.execute(args, abortSignal);
+      const invocation = tool.build(args);
+      const confirmationDetails =
+        await invocation.shouldConfirmExecute(abortSignal);
+      if (confirmationDetails) {
+        let content: acp.ToolCallContent | null = null;
+        if (confirmationDetails.type === 'edit') {
+          content = {
+            type: 'diff',
+            path: confirmationDetails.fileName,
+            oldText: confirmationDetails.originalContent,
+            newText: confirmationDetails.newContent,
+          };
+        }
+
+        const result = await this.client.requestToolCallConfirmation({
+          label: invocation.getDescription(),
+          icon: tool.icon,
+          content,
+          confirmation: toAcpToolCallConfirmation(confirmationDetails),
+          locations: invocation.toolLocations(),
+        });
+
+        await confirmationDetails.onConfirm(toToolCallOutcome(result.outcome));
+        switch (result.outcome) {
+          case 'reject':
+            return errorResponse(
+              new Error(`Tool "${fc.name}" not allowed to run by the user.`),
+            );
+
+          case 'cancel':
+            return errorResponse(
+              new Error(`Tool "${fc.name}" was canceled by the user.`),
+            );
+          case 'allow':
+          case 'alwaysAllow':
+          case 'alwaysAllowMcpServer':
+          case 'alwaysAllowTool':
+            break;
+          default: {
+            const resultOutcome: never = result.outcome;
+            throw new Error(`Unexpected: ${resultOutcome}`);
+          }
+        }
+        toolCallId = result.id;
+      } else {
+        const result = await this.client.pushToolCall({
+          icon: tool.icon,
+          label: invocation.getDescription(),
+          locations: invocation.toolLocations(),
+        });
+        toolCallId = result.id;
+      }
+
+      const toolResult: ToolResult = await invocation.execute(abortSignal);
       const toolCallContent = toToolCallContent(toolResult);
 
       await this.client.updateToolCall({
@@ -320,12 +317,13 @@ class GeminiAgent implements Agent {
       return convertToFunctionResponse(fc.name, callId, toolResult.llmContent);
     } catch (e) {
       const error = e instanceof Error ? e : new Error(String(e));
-      await this.client.updateToolCall({
-        toolCallId,
-        status: 'error',
-        content: { type: 'markdown', markdown: error.message },
-      });
-
+      if (toolCallId) {
+        await this.client.updateToolCall({
+          toolCallId,
+          status: 'error',
+          content: { type: 'markdown', markdown: error.message },
+        });
+      }
       return errorResponse(error);
     }
   }
@@ -408,7 +406,7 @@ class GeminiAgent implements Agent {
               `Path ${pathName} not found directly, attempting glob search.`,
             );
             try {
-              const globResult = await globTool.execute(
+              const globResult = await globTool.buildAndExecute(
                 {
                   pattern: `**/*${pathName}*`,
                   path: this.config.getTargetDir(),
@@ -530,12 +528,15 @@ class GeminiAgent implements Agent {
       respectGitIgnore, // Use configuration setting
     };
 
-    const toolCall = await this.client.pushToolCall({
-      icon: readManyFilesTool.icon,
-      label: readManyFilesTool.getDescription(toolArgs),
-    });
+    let toolCallId: number | undefined = undefined;
     try {
-      const result = await readManyFilesTool.execute(toolArgs, abortSignal);
+      const invocation = readManyFilesTool.build(toolArgs);
+      const toolCall = await this.client.pushToolCall({
+        icon: readManyFilesTool.icon,
+        label: invocation.getDescription(),
+      });
+      toolCallId = toolCall.id;
+      const result = await invocation.execute(abortSignal);
       const content = toToolCallContent(result) || {
         type: 'markdown',
         markdown: `Successfully read: ${contentLabelsForDisplay.join(', ')}`,
@@ -578,14 +579,16 @@ class GeminiAgent implements Agent {
 
       return processedQueryParts;
     } catch (error: unknown) {
-      await this.client.updateToolCall({
-        toolCallId: toolCall.id,
-        status: 'error',
-        content: {
-          type: 'markdown',
-          markdown: `Error reading files (${contentLabelsForDisplay.join(', ')}): ${getErrorMessage(error)}`,
-        },
-      });
+      if (toolCallId) {
+        await this.client.updateToolCall({
+          toolCallId,
+          status: 'error',
+          content: {
+            type: 'markdown',
+            markdown: `Error reading files (${contentLabelsForDisplay.join(', ')}): ${getErrorMessage(error)}`,
+          },
+        });
+      }
       throw error;
     }
   }
diff --git a/packages/cli/src/ui/hooks/atCommandProcessor.ts b/packages/cli/src/ui/hooks/atCommandProcessor.ts
index 165b7b30..cef2f811 100644
--- a/packages/cli/src/ui/hooks/atCommandProcessor.ts
+++ b/packages/cli/src/ui/hooks/atCommandProcessor.ts
@@ -8,6 +8,7 @@ import * as fs from 'fs/promises';
 import * as path from 'path';
 import { PartListUnion, PartUnion } from '@google/genai';
 import {
+  AnyToolInvocation,
   Config,
   getErrorMessage,
   isNodeError,
@@ -254,7 +255,7 @@ export async function handleAtCommand({
               `Path ${pathName} not found directly, attempting glob search.`,
             );
             try {
-              const globResult = await globTool.execute(
+              const globResult = await globTool.buildAndExecute(
                 {
                   pattern: `**/*${pathName}*`,
                   path: dir,
@@ -411,12 +412,14 @@ export async function handleAtCommand({
   };
   let toolCallDisplay: IndividualToolCallDisplay;
 
+  let invocation: AnyToolInvocation | undefined = undefined;
   try {
-    const result = await readManyFilesTool.execute(toolArgs, signal);
+    invocation = readManyFilesTool.build(toolArgs);
+    const result = await invocation.execute(signal);
     toolCallDisplay = {
       callId: `client-read-${userMessageTimestamp}`,
       name: readManyFilesTool.displayName,
-      description: readManyFilesTool.getDescription(toolArgs),
+      description: invocation.getDescription(),
       status: ToolCallStatus.Success,
       resultDisplay:
         result.returnDisplay ||
@@ -466,7 +469,9 @@ export async function handleAtCommand({
     toolCallDisplay = {
       callId: `client-read-${userMessageTimestamp}`,
       name: readManyFilesTool.displayName,
-      description: readManyFilesTool.getDescription(toolArgs),
+      description:
+        invocation?.getDescription() ??
+        'Error attempting to execute tool to read files',
       status: ToolCallStatus.Error,
       resultDisplay: `Error reading files (${contentLabelsForDisplay.join(', ')}): ${getErrorMessage(error)}`,
       confirmationDetails: undefined,
diff --git a/packages/cli/src/ui/hooks/useGeminiStream.test.tsx b/packages/cli/src/ui/hooks/useGeminiStream.test.tsx
index 062c1687..dd2428bb 100644
--- a/packages/cli/src/ui/hooks/useGeminiStream.test.tsx
+++ b/packages/cli/src/ui/hooks/useGeminiStream.test.tsx
@@ -21,6 +21,7 @@ import {
   EditorType,
   AuthType,
   GeminiEventType as ServerGeminiEventType,
+  AnyToolInvocation,
 } from '@google/gemini-cli-core';
 import { Part, PartListUnion } from '@google/genai';
 import { UseHistoryManagerReturn } from './useHistoryManager.js';
@@ -452,9 +453,13 @@ describe('useGeminiStream', () => {
         },
         tool: {
           name: 'tool1',
+          displayName: 'tool1',
           description: 'desc1',
-          getDescription: vi.fn(),
+          build: vi.fn(),
         } as any,
+        invocation: {
+          getDescription: () => `Mock description`,
+        } as unknown as AnyToolInvocation,
         startTime: Date.now(),
         endTime: Date.now(),
       } as TrackedCompletedToolCall,
@@ -469,9 +474,13 @@ describe('useGeminiStream', () => {
         responseSubmittedToGemini: false,
         tool: {
           name: 'tool2',
+          displayName: 'tool2',
           description: 'desc2',
-          getDescription: vi.fn(),
+          build: vi.fn(),
         } as any,
+        invocation: {
+          getDescription: () => `Mock description`,
+        } as unknown as AnyToolInvocation,
         startTime: Date.now(),
         liveOutput: '...',
       } as TrackedExecutingToolCall,
@@ -506,6 +515,12 @@ describe('useGeminiStream', () => {
         status: 'success',
         responseSubmittedToGemini: false,
         response: { callId: 'call1', responseParts: toolCall1ResponseParts },
+        tool: {
+          displayName: 'MockTool',
+        },
+        invocation: {
+          getDescription: () => `Mock description`,
+        } as unknown as AnyToolInvocation,
       } as TrackedCompletedToolCall,
       {
         request: {
@@ -584,6 +599,12 @@ describe('useGeminiStream', () => {
         status: 'cancelled',
         response: { callId: '1', responseParts: [{ text: 'cancelled' }] },
         responseSubmittedToGemini: false,
+        tool: {
+          displayName: 'mock tool',
+        },
+        invocation: {
+          getDescription: () => `Mock description`,
+        } as unknown as AnyToolInvocation,
       } as TrackedCancelledToolCall,
     ];
     const client = new MockedGeminiClientClass(mockConfig);
@@ -644,9 +665,13 @@ describe('useGeminiStream', () => {
       },
       tool: {
         name: 'toolA',
+        displayName: 'toolA',
         description: 'descA',
-        getDescription: vi.fn(),
+        build: vi.fn(),
       } as any,
+      invocation: {
+        getDescription: () => `Mock description`,
+      } as unknown as AnyToolInvocation,
       status: 'cancelled',
       response: {
         callId: 'cancel-1',
@@ -668,9 +693,13 @@ describe('useGeminiStream', () => {
       },
       tool: {
         name: 'toolB',
+        displayName: 'toolB',
         description: 'descB',
-        getDescription: vi.fn(),
+        build: vi.fn(),
       } as any,
+      invocation: {
+        getDescription: () => `Mock description`,
+      } as unknown as AnyToolInvocation,
       status: 'cancelled',
       response: {
         callId: 'cancel-2',
@@ -760,9 +789,13 @@ describe('useGeminiStream', () => {
         responseSubmittedToGemini: false,
         tool: {
           name: 'tool1',
+          displayName: 'tool1',
           description: 'desc',
-          getDescription: vi.fn(),
+          build: vi.fn(),
         } as any,
+        invocation: {
+          getDescription: () => `Mock description`,
+        } as unknown as AnyToolInvocation,
         startTime: Date.now(),
       } as TrackedExecutingToolCall,
     ];
@@ -980,8 +1013,13 @@ describe('useGeminiStream', () => {
           tool: {
             name: 'tool1',
             description: 'desc1',
-            getDescription: vi.fn(),
+            build: vi.fn().mockImplementation((_) => ({
+              getDescription: () => `Mock description`,
+            })),
           } as any,
+          invocation: {
+            getDescription: () => `Mock description`,
+          },
           startTime: Date.now(),
           liveOutput: '...',
         } as TrackedExecutingToolCall,
@@ -1131,9 +1169,13 @@ describe('useGeminiStream', () => {
         },
         tool: {
           name: 'save_memory',
+          displayName: 'save_memory',
           description: 'Saves memory',
-          getDescription: vi.fn(),
+          build: vi.fn(),
         } as any,
+        invocation: {
+          getDescription: () => `Mock description`,
+        } as unknown as AnyToolInvocation,
       };
 
       // Capture the onComplete callback
diff --git a/packages/cli/src/ui/hooks/useReactToolScheduler.ts b/packages/cli/src/ui/hooks/useReactToolScheduler.ts
index 01993650..c6b802fc 100644
--- a/packages/cli/src/ui/hooks/useReactToolScheduler.ts
+++ b/packages/cli/src/ui/hooks/useReactToolScheduler.ts
@@ -17,7 +17,6 @@ import {
   OutputUpdateHandler,
   AllToolCallsCompleteHandler,
   ToolCallsUpdateHandler,
-  Tool,
   ToolCall,
   Status as CoreStatus,
   EditorType,
@@ -216,23 +215,20 @@ export function mapToDisplay(
 
   const toolDisplays = toolCalls.map(
     (trackedCall): IndividualToolCallDisplay => {
-      let displayName = trackedCall.request.name;
-      let description = '';
+      let displayName: string;
+      let description: string;
       let renderOutputAsMarkdown = false;
 
-      const currentToolInstance =
-        'tool' in trackedCall && trackedCall.tool
-          ? (trackedCall as { tool: Tool }).tool
-          : undefined;
-
-      if (currentToolInstance) {
-        displayName = currentToolInstance.displayName;
-        description = currentToolInstance.getDescription(
-          trackedCall.request.args,
-        );
-        renderOutputAsMarkdown = currentToolInstance.isOutputMarkdown;
-      } else if ('request' in trackedCall && 'args' in trackedCall.request) {
+      if (trackedCall.status === 'error') {
+        displayName =
+          trackedCall.tool === undefined
+            ? trackedCall.request.name
+            : trackedCall.tool.displayName;
         description = JSON.stringify(trackedCall.request.args);
+      } else {
+        displayName = trackedCall.tool.displayName;
+        description = trackedCall.invocation.getDescription();
+        renderOutputAsMarkdown = trackedCall.tool.isOutputMarkdown;
       }
 
       const baseDisplayProperties: Omit<
@@ -256,7 +252,6 @@ export function mapToDisplay(
         case 'error':
           return {
             ...baseDisplayProperties,
-            name: currentToolInstance?.displayName ?? trackedCall.request.name,
             status: mapCoreStatusToDisplayStatus(trackedCall.status),
             resultDisplay: trackedCall.response.resultDisplay,
             confirmationDetails: undefined,
diff --git a/packages/cli/src/ui/hooks/useToolScheduler.test.ts b/packages/cli/src/ui/hooks/useToolScheduler.test.ts
index 5395d18a..ee5251d3 100644
--- a/packages/cli/src/ui/hooks/useToolScheduler.test.ts
+++ b/packages/cli/src/ui/hooks/useToolScheduler.test.ts
@@ -15,7 +15,6 @@ import { PartUnion, FunctionResponse } from '@google/genai';
 import {
   Config,
   ToolCallRequestInfo,
-  Tool,
   ToolRegistry,
   ToolResult,
   ToolCallConfirmationDetails,
@@ -25,6 +24,9 @@ import {
   Status as ToolCallStatusType,
   ApprovalMode,
   Icon,
+  BaseTool,
+  AnyDeclarativeTool,
+  AnyToolInvocation,
 } from '@google/gemini-cli-core';
 import {
   HistoryItemWithoutId,
@@ -53,46 +55,55 @@ const mockConfig = {
   getDebugMode: () => false,
 };
 
-const mockTool: Tool = {
-  name: 'mockTool',
-  displayName: 'Mock Tool',
-  description: 'A mock tool for testing',
-  icon: Icon.Hammer,
-  toolLocations: vi.fn(),
-  isOutputMarkdown: false,
-  canUpdateOutput: false,
-  schema: {},
-  validateToolParams: vi.fn(),
-  execute: vi.fn(),
-  shouldConfirmExecute: vi.fn(),
-  getDescription: vi.fn((args) => `Description for ${JSON.stringify(args)}`),
-};
+class MockTool extends BaseTool<object, ToolResult> {
+  constructor(
+    name: string,
+    displayName: string,
+    canUpdateOutput = false,
+    shouldConfirm = false,
+    isOutputMarkdown = false,
+  ) {
+    super(
+      name,
+      displayName,
+      'A mock tool for testing',
+      Icon.Hammer,
+      {},
+      isOutputMarkdown,
+      canUpdateOutput,
+    );
+    if (shouldConfirm) {
+      this.shouldConfirmExecute = vi.fn(
+        async (): Promise<ToolCallConfirmationDetails | false> => ({
+          type: 'edit',
+          title: 'Mock Tool Requires Confirmation',
+          onConfirm: mockOnUserConfirmForToolConfirmation,
+          fileName: 'mockToolRequiresConfirmation.ts',
+          fileDiff: 'Mock tool requires confirmation',
+          originalContent: 'Original content',
+          newContent: 'New content',
+        }),
+      );
+    }
+  }
 
-const mockToolWithLiveOutput: Tool = {
-  ...mockTool,
-  name: 'mockToolWithLiveOutput',
-  displayName: 'Mock Tool With Live Output',
-  canUpdateOutput: true,
-};
+  execute = vi.fn();
+  shouldConfirmExecute = vi.fn();
+}
 
+const mockTool = new MockTool('mockTool', 'Mock Tool');
+const mockToolWithLiveOutput = new MockTool(
+  'mockToolWithLiveOutput',
+  'Mock Tool With Live Output',
+  true,
+);
 let mockOnUserConfirmForToolConfirmation: Mock;
-
-const mockToolRequiresConfirmation: Tool = {
-  ...mockTool,
-  name: 'mockToolRequiresConfirmation',
-  displayName: 'Mock Tool Requires Confirmation',
-  shouldConfirmExecute: vi.fn(
-    async (): Promise<ToolCallConfirmationDetails | false> => ({
-      type: 'edit',
-      title: 'Mock Tool Requires Confirmation',
-      onConfirm: mockOnUserConfirmForToolConfirmation,
-      fileName: 'mockToolRequiresConfirmation.ts',
-      fileDiff: 'Mock tool requires confirmation',
-      originalContent: 'Original content',
-      newContent: 'New content',
-    }),
-  ),
-};
+const mockToolRequiresConfirmation = new MockTool(
+  'mockToolRequiresConfirmation',
+  'Mock Tool Requires Confirmation',
+  false,
+  true,
+);
 
 describe('useReactToolScheduler in YOLO Mode', () => {
   let onComplete: Mock;
@@ -646,28 +657,21 @@ describe('useReactToolScheduler', () => {
   });
 
   it('should schedule and execute multiple tool calls', async () => {
-    const tool1 = {
-      ...mockTool,
-      name: 'tool1',
-      displayName: 'Tool 1',
-      execute: vi.fn().mockResolvedValue({
-        llmContent: 'Output 1',
-        returnDisplay: 'Display 1',
-        summary: 'Summary 1',
-      } as ToolResult),
-      shouldConfirmExecute: vi.fn().mockResolvedValue(null),
-    };
-    const tool2 = {
-      ...mockTool,
-      name: 'tool2',
-      displayName: 'Tool 2',
-      execute: vi.fn().mockResolvedValue({
-        llmContent: 'Output 2',
-        returnDisplay: 'Display 2',
-        summary: 'Summary 2',
-      } as ToolResult),
-      shouldConfirmExecute: vi.fn().mockResolvedValue(null),
-    };
+    const tool1 = new MockTool('tool1', 'Tool 1');
+    tool1.execute.mockResolvedValue({
+      llmContent: 'Output 1',
+      returnDisplay: 'Display 1',
+      summary: 'Summary 1',
+    } as ToolResult);
+    tool1.shouldConfirmExecute.mockResolvedValue(null);
+
+    const tool2 = new MockTool('tool2', 'Tool 2');
+    tool2.execute.mockResolvedValue({
+      llmContent: 'Output 2',
+      returnDisplay: 'Display 2',
+      summary: 'Summary 2',
+    } as ToolResult);
+    tool2.shouldConfirmExecute.mockResolvedValue(null);
 
     mockToolRegistry.getTool.mockImplementation((name) => {
       if (name === 'tool1') return tool1;
@@ -805,20 +809,7 @@ describe('mapToDisplay', () => {
     args: { foo: 'bar' },
   };
 
-  const baseTool: Tool = {
-    name: 'testTool',
-    displayName: 'Test Tool Display',
-    description: 'Test Description',
-    isOutputMarkdown: false,
-    canUpdateOutput: false,
-    schema: {},
-    icon: Icon.Hammer,
-    toolLocations: vi.fn(),
-    validateToolParams: vi.fn(),
-    execute: vi.fn(),
-    shouldConfirmExecute: vi.fn(),
-    getDescription: vi.fn((args) => `Desc: ${JSON.stringify(args)}`),
-  };
+  const baseTool = new MockTool('testTool', 'Test Tool Display');
 
   const baseResponse: ToolCallResponseInfo = {
     callId: 'testCallId',
@@ -840,13 +831,15 @@ describe('mapToDisplay', () => {
   // This helps ensure that tool and confirmationDetails are only accessed when they are expected to exist.
   type MapToDisplayExtraProps =
     | {
-        tool?: Tool;
+        tool?: AnyDeclarativeTool;
+        invocation?: AnyToolInvocation;
         liveOutput?: string;
         response?: ToolCallResponseInfo;
         confirmationDetails?: ToolCallConfirmationDetails;
       }
     | {
-        tool: Tool;
+        tool: AnyDeclarativeTool;
+        invocation?: AnyToolInvocation;
         response?: ToolCallResponseInfo;
         confirmationDetails?: ToolCallConfirmationDetails;
       }
@@ -857,10 +850,12 @@ describe('mapToDisplay', () => {
       }
     | {
         confirmationDetails: ToolCallConfirmationDetails;
-        tool?: Tool;
+        tool?: AnyDeclarativeTool;
+        invocation?: AnyToolInvocation;
         response?: ToolCallResponseInfo;
       };
 
+  const baseInvocation = baseTool.build(baseRequest.args);
   const testCases: Array<{
     name: string;
     status: ToolCallStatusType;
@@ -873,7 +868,7 @@ describe('mapToDisplay', () => {
     {
       name: 'validating',
       status: 'validating',
-      extraProps: { tool: baseTool },
+      extraProps: { tool: baseTool, invocation: baseInvocation },
       expectedStatus: ToolCallStatus.Executing,
       expectedName: baseTool.displayName,
       expectedDescription: baseTool.getDescription(baseRequest.args),
@@ -883,6 +878,7 @@ describe('mapToDisplay', () => {
       status: 'awaiting_approval',
       extraProps: {
         tool: baseTool,
+        invocation: baseInvocation,
         confirmationDetails: {
           onConfirm: vi.fn(),
           type: 'edit',
@@ -903,7 +899,7 @@ describe('mapToDisplay', () => {
     {
       name: 'scheduled',
       status: 'scheduled',
-      extraProps: { tool: baseTool },
+      extraProps: { tool: baseTool, invocation: baseInvocation },
       expectedStatus: ToolCallStatus.Pending,
       expectedName: baseTool.displayName,
       expectedDescription: baseTool.getDescription(baseRequest.args),
@@ -911,7 +907,7 @@ describe('mapToDisplay', () => {
     {
       name: 'executing no live output',
       status: 'executing',
-      extraProps: { tool: baseTool },
+      extraProps: { tool: baseTool, invocation: baseInvocation },
       expectedStatus: ToolCallStatus.Executing,
       expectedName: baseTool.displayName,
       expectedDescription: baseTool.getDescription(baseRequest.args),
@@ -919,7 +915,11 @@ describe('mapToDisplay', () => {
     {
       name: 'executing with live output',
       status: 'executing',
-      extraProps: { tool: baseTool, liveOutput: 'Live test output' },
+      extraProps: {
+        tool: baseTool,
+        invocation: baseInvocation,
+        liveOutput: 'Live test output',
+      },
       expectedStatus: ToolCallStatus.Executing,
       expectedResultDisplay: 'Live test output',
       expectedName: baseTool.displayName,
@@ -928,7 +928,11 @@ describe('mapToDisplay', () => {
     {
       name: 'success',
       status: 'success',
-      extraProps: { tool: baseTool, response: baseResponse },
+      extraProps: {
+        tool: baseTool,
+        invocation: baseInvocation,
+        response: baseResponse,
+      },
       expectedStatus: ToolCallStatus.Success,
       expectedResultDisplay: baseResponse.resultDisplay as any,
       expectedName: baseTool.displayName,
@@ -970,6 +974,7 @@ describe('mapToDisplay', () => {
       status: 'cancelled',
       extraProps: {
         tool: baseTool,
+        invocation: baseInvocation,
         response: {
           ...baseResponse,
           resultDisplay: 'Cancelled display',
@@ -1030,12 +1035,21 @@ describe('mapToDisplay', () => {
       request: { ...baseRequest, callId: 'call1' },
       status: 'success',
       tool: baseTool,
+      invocation: baseTool.build(baseRequest.args),
       response: { ...baseResponse, callId: 'call1' },
     } as ToolCall;
+    const toolForCall2 = new MockTool(
+      baseTool.name,
+      baseTool.displayName,
+      false,
+      false,
+      true,
+    );
     const toolCall2: ToolCall = {
       request: { ...baseRequest, callId: 'call2' },
       status: 'executing',
-      tool: { ...baseTool, isOutputMarkdown: true },
+      tool: toolForCall2,
+      invocation: toolForCall2.build(baseRequest.args),
       liveOutput: 'markdown output',
     } as ToolCall;
 
diff --git a/packages/core/src/core/client.ts b/packages/core/src/core/client.ts
index 3b6b57f9..f8b9a7de 100644
--- a/packages/core/src/core/client.ts
+++ b/packages/core/src/core/client.ts
@@ -24,7 +24,6 @@ import {
 import { Config } from '../config/config.js';
 import { UserTierId } from '../code_assist/types.js';
 import { getCoreSystemPrompt, getCompressionPrompt } from './prompts.js';
-import { ReadManyFilesTool } from '../tools/read-many-files.js';
 import { getResponseText } from '../utils/generateContentResponseUtilities.js';
 import { checkNextSpeaker } from '../utils/nextSpeakerChecker.js';
 import { reportError } from '../utils/errorReporting.js';
@@ -252,18 +251,15 @@ export class GeminiClient {
     // Add full file context if the flag is set
     if (this.config.getFullContext()) {
       try {
-        const readManyFilesTool = toolRegistry.getTool(
-          'read_many_files',
-        ) as ReadManyFilesTool;
+        const readManyFilesTool = toolRegistry.getTool('read_many_files');
         if (readManyFilesTool) {
+          const invocation = readManyFilesTool.build({
+            paths: ['**/*'], // Read everything recursively
+            useDefaultExcludes: true, // Use default excludes
+          });
+
           // Read all files in the target directory
-          const result = await readManyFilesTool.execute(
-            {
-              paths: ['**/*'], // Read everything recursively
-              useDefaultExcludes: true, // Use default excludes
-            },
-            AbortSignal.timeout(30000),
-          );
+          const result = await invocation.execute(AbortSignal.timeout(30000));
           if (result.llmContent) {
             initialParts.push({
               text: `\n--- Full File Context ---\n${result.llmContent}`,
diff --git a/packages/core/src/core/coreToolScheduler.test.ts b/packages/core/src/core/coreToolScheduler.test.ts
index 4d786d00..a65443f8 100644
--- a/packages/core/src/core/coreToolScheduler.test.ts
+++ b/packages/core/src/core/coreToolScheduler.test.ts
@@ -24,44 +24,15 @@ import {
 } from '../index.js';
 import { Part, PartListUnion } from '@google/genai';
 
-import { ModifiableTool, ModifyContext } from '../tools/modifiable-tool.js';
-
-class MockTool extends BaseTool<Record<string, unknown>, ToolResult> {
-  shouldConfirm = false;
-  executeFn = vi.fn();
-
-  constructor(name = 'mockTool') {
-    super(name, name, 'A mock tool', Icon.Hammer, {});
-  }
-
-  async shouldConfirmExecute(
-    _params: Record<string, unknown>,
-    _abortSignal: AbortSignal,
-  ): Promise<ToolCallConfirmationDetails | false> {
-    if (this.shouldConfirm) {
-      return {
-        type: 'exec',
-        title: 'Confirm Mock Tool',
-        command: 'do_thing',
-        rootCommand: 'do_thing',
-        onConfirm: async () => {},
-      };
-    }
-    return false;
-  }
-
-  async execute(
-    params: Record<string, unknown>,
-    _abortSignal: AbortSignal,
-  ): Promise<ToolResult> {
-    this.executeFn(params);
-    return { llmContent: 'Tool executed', returnDisplay: 'Tool executed' };
-  }
-}
+import {
+  ModifiableDeclarativeTool,
+  ModifyContext,
+} from '../tools/modifiable-tool.js';
+import { MockTool } from '../test-utils/tools.js';
 
 class MockModifiableTool
   extends MockTool
-  implements ModifiableTool<Record<string, unknown>>
+  implements ModifiableDeclarativeTool<Record<string, unknown>>
 {
   constructor(name = 'mockModifiableTool') {
     super(name);
@@ -83,10 +54,7 @@ class MockModifiableTool
     };
   }
 
-  async shouldConfirmExecute(
-    _params: Record<string, unknown>,
-    _abortSignal: AbortSignal,
-  ): Promise<ToolCallConfirmationDetails | false> {
+  async shouldConfirmExecute(): Promise<ToolCallConfirmationDetails | false> {
     if (this.shouldConfirm) {
       return {
         type: 'edit',
@@ -107,14 +75,15 @@ describe('CoreToolScheduler', () => {
   it('should cancel a tool call if the signal is aborted before confirmation', async () => {
     const mockTool = new MockTool();
     mockTool.shouldConfirm = true;
+    const declarativeTool = mockTool;
     const toolRegistry = {
-      getTool: () => mockTool,
+      getTool: () => declarativeTool,
       getFunctionDeclarations: () => [],
       tools: new Map(),
       discovery: {} as any,
       registerTool: () => {},
-      getToolByName: () => mockTool,
-      getToolByDisplayName: () => mockTool,
+      getToolByName: () => declarativeTool,
+      getToolByDisplayName: () => declarativeTool,
       getTools: () => [],
       discoverTools: async () => {},
       getAllTools: () => [],
@@ -177,14 +146,15 @@ describe('CoreToolScheduler', () => {
 describe('CoreToolScheduler with payload', () => {
   it('should update args and diff and execute tool when payload is provided', async () => {
     const mockTool = new MockModifiableTool();
+    const declarativeTool = mockTool;
     const toolRegistry = {
-      getTool: () => mockTool,
+      getTool: () => declarativeTool,
       getFunctionDeclarations: () => [],
       tools: new Map(),
       discovery: {} as any,
       registerTool: () => {},
-      getToolByName: () => mockTool,
-      getToolByDisplayName: () => mockTool,
+      getToolByName: () => declarativeTool,
+      getToolByDisplayName: () => declarativeTool,
       getTools: () => [],
       discoverTools: async () => {},
       getAllTools: () => [],
@@ -221,10 +191,7 @@ describe('CoreToolScheduler with payload', () => {
 
     await scheduler.schedule([request], abortController.signal);
 
-    const confirmationDetails = await mockTool.shouldConfirmExecute(
-      {},
-      abortController.signal,
-    );
+    const confirmationDetails = await mockTool.shouldConfirmExecute();
 
     if (confirmationDetails) {
       const payload: ToolConfirmationPayload = { newContent: 'final version' };
@@ -456,14 +423,15 @@ describe('CoreToolScheduler edit cancellation', () => {
     }
 
     const mockEditTool = new MockEditTool();
+    const declarativeTool = mockEditTool;
     const toolRegistry = {
-      getTool: () => mockEditTool,
+      getTool: () => declarativeTool,
       getFunctionDeclarations: () => [],
       tools: new Map(),
       discovery: {} as any,
       registerTool: () => {},
-      getToolByName: () => mockEditTool,
-      getToolByDisplayName: () => mockEditTool,
+      getToolByName: () => declarativeTool,
+      getToolByDisplayName: () => declarativeTool,
       getTools: () => [],
       discoverTools: async () => {},
       getAllTools: () => [],
@@ -541,18 +509,23 @@ describe('CoreToolScheduler YOLO mode', () => {
   it('should execute tool requiring confirmation directly without waiting', async () => {
     // Arrange
     const mockTool = new MockTool();
+    mockTool.executeFn.mockReturnValue({
+      llmContent: 'Tool executed',
+      returnDisplay: 'Tool executed',
+    });
     // This tool would normally require confirmation.
     mockTool.shouldConfirm = true;
+    const declarativeTool = mockTool;
 
     const toolRegistry = {
-      getTool: () => mockTool,
-      getToolByName: () => mockTool,
+      getTool: () => declarativeTool,
+      getToolByName: () => declarativeTool,
       // Other properties are not needed for this test but are included for type consistency.
       getFunctionDeclarations: () => [],
       tools: new Map(),
       discovery: {} as any,
       registerTool: () => {},
-      getToolByDisplayName: () => mockTool,
+      getToolByDisplayName: () => declarativeTool,
       getTools: () => [],
       discoverTools: async () => {},
       getAllTools: () => [],
diff --git a/packages/core/src/core/coreToolScheduler.ts b/packages/core/src/core/coreToolScheduler.ts
index 9b999b6b..6f098ae3 100644
--- a/packages/core/src/core/coreToolScheduler.ts
+++ b/packages/core/src/core/coreToolScheduler.ts
@@ -8,7 +8,6 @@ import {
   ToolCallRequestInfo,
   ToolCallResponseInfo,
   ToolConfirmationOutcome,
-  Tool,
   ToolCallConfirmationDetails,
   ToolResult,
   ToolResultDisplay,
@@ -20,11 +19,13 @@ import {
   ToolCallEvent,
   ToolConfirmationPayload,
   ToolErrorType,
+  AnyDeclarativeTool,
+  AnyToolInvocation,
 } from '../index.js';
 import { Part, PartListUnion } from '@google/genai';
 import { getResponseTextFromParts } from '../utils/generateContentResponseUtilities.js';
 import {
-  isModifiableTool,
+  isModifiableDeclarativeTool,
   ModifyContext,
   modifyWithEditor,
 } from '../tools/modifiable-tool.js';
@@ -33,7 +34,8 @@ import * as Diff from 'diff';
 export type ValidatingToolCall = {
   status: 'validating';
   request: ToolCallRequestInfo;
-  tool: Tool;
+  tool: AnyDeclarativeTool;
+  invocation: AnyToolInvocation;
   startTime?: number;
   outcome?: ToolConfirmationOutcome;
 };
@@ -41,7 +43,8 @@ export type ValidatingToolCall = {
 export type ScheduledToolCall = {
   status: 'scheduled';
   request: ToolCallRequestInfo;
-  tool: Tool;
+  tool: AnyDeclarativeTool;
+  invocation: AnyToolInvocation;
   startTime?: number;
   outcome?: ToolConfirmationOutcome;
 };
@@ -50,6 +53,7 @@ export type ErroredToolCall = {
   status: 'error';
   request: ToolCallRequestInfo;
   response: ToolCallResponseInfo;
+  tool?: AnyDeclarativeTool;
   durationMs?: number;
   outcome?: ToolConfirmationOutcome;
 };
@@ -57,8 +61,9 @@ export type ErroredToolCall = {
 export type SuccessfulToolCall = {
   status: 'success';
   request: ToolCallRequestInfo;
-  tool: Tool;
+  tool: AnyDeclarativeTool;
   response: ToolCallResponseInfo;
+  invocation: AnyToolInvocation;
   durationMs?: number;
   outcome?: ToolConfirmationOutcome;
 };
@@ -66,7 +71,8 @@ export type SuccessfulToolCall = {
 export type ExecutingToolCall = {
   status: 'executing';
   request: ToolCallRequestInfo;
-  tool: Tool;
+  tool: AnyDeclarativeTool;
+  invocation: AnyToolInvocation;
   liveOutput?: string;
   startTime?: number;
   outcome?: ToolConfirmationOutcome;
@@ -76,7 +82,8 @@ export type CancelledToolCall = {
   status: 'cancelled';
   request: ToolCallRequestInfo;
   response: ToolCallResponseInfo;
-  tool: Tool;
+  tool: AnyDeclarativeTool;
+  invocation: AnyToolInvocation;
   durationMs?: number;
   outcome?: ToolConfirmationOutcome;
 };
@@ -84,7 +91,8 @@ export type CancelledToolCall = {
 export type WaitingToolCall = {
   status: 'awaiting_approval';
   request: ToolCallRequestInfo;
-  tool: Tool;
+  tool: AnyDeclarativeTool;
+  invocation: AnyToolInvocation;
   confirmationDetails: ToolCallConfirmationDetails;
   startTime?: number;
   outcome?: ToolConfirmationOutcome;
@@ -289,6 +297,7 @@ export class CoreToolScheduler {
       // currentCall is a non-terminal state here and should have startTime and tool.
       const existingStartTime = currentCall.startTime;
       const toolInstance = currentCall.tool;
+      const invocation = currentCall.invocation;
 
       const outcome = currentCall.outcome;
 
@@ -300,6 +309,7 @@ export class CoreToolScheduler {
           return {
             request: currentCall.request,
             tool: toolInstance,
+            invocation,
             status: 'success',
             response: auxiliaryData as ToolCallResponseInfo,
             durationMs,
@@ -313,6 +323,7 @@ export class CoreToolScheduler {
           return {
             request: currentCall.request,
             status: 'error',
+            tool: toolInstance,
             response: auxiliaryData as ToolCallResponseInfo,
             durationMs,
             outcome,
@@ -326,6 +337,7 @@ export class CoreToolScheduler {
             confirmationDetails: auxiliaryData as ToolCallConfirmationDetails,
             startTime: existingStartTime,
             outcome,
+            invocation,
           } as WaitingToolCall;
         case 'scheduled':
           return {
@@ -334,6 +346,7 @@ export class CoreToolScheduler {
             status: 'scheduled',
             startTime: existingStartTime,
             outcome,
+            invocation,
           } as ScheduledToolCall;
         case 'cancelled': {
           const durationMs = existingStartTime
@@ -358,6 +371,7 @@ export class CoreToolScheduler {
           return {
             request: currentCall.request,
             tool: toolInstance,
+            invocation,
             status: 'cancelled',
             response: {
               callId: currentCall.request.callId,
@@ -385,6 +399,7 @@ export class CoreToolScheduler {
             status: 'validating',
             startTime: existingStartTime,
             outcome,
+            invocation,
           } as ValidatingToolCall;
         case 'executing':
           return {
@@ -393,6 +408,7 @@ export class CoreToolScheduler {
             status: 'executing',
             startTime: existingStartTime,
             outcome,
+            invocation,
           } as ExecutingToolCall;
         default: {
           const exhaustiveCheck: never = newStatus;
@@ -406,10 +422,34 @@ export class CoreToolScheduler {
 
   private setArgsInternal(targetCallId: string, args: unknown): void {
     this.toolCalls = this.toolCalls.map((call) => {
-      if (call.request.callId !== targetCallId) return call;
+      // We should never be asked to set args on an ErroredToolCall, but
+      // we guard for the case anyways.
+      if (call.request.callId !== targetCallId || call.status === 'error') {
+        return call;
+      }
+
+      const invocationOrError = this.buildInvocation(
+        call.tool,
+        args as Record<string, unknown>,
+      );
+      if (invocationOrError instanceof Error) {
+        const response = createErrorResponse(
+          call.request,
+          invocationOrError,
+          ToolErrorType.INVALID_TOOL_PARAMS,
+        );
+        return {
+          request: { ...call.request, args: args as Record<string, unknown> },
+          status: 'error',
+          tool: call.tool,
+          response,
+        } as ErroredToolCall;
+      }
+
       return {
         ...call,
         request: { ...call.request, args: args as Record<string, unknown> },
+        invocation: invocationOrError,
       };
     });
   }
@@ -421,6 +461,20 @@ export class CoreToolScheduler {
     );
   }
 
+  private buildInvocation(
+    tool: AnyDeclarativeTool,
+    args: object,
+  ): AnyToolInvocation | Error {
+    try {
+      return tool.build(args);
+    } catch (e) {
+      if (e instanceof Error) {
+        return e;
+      }
+      return new Error(String(e));
+    }
+  }
+
   async schedule(
     request: ToolCallRequestInfo | ToolCallRequestInfo[],
     signal: AbortSignal,
@@ -448,10 +502,30 @@ export class CoreToolScheduler {
             durationMs: 0,
           };
         }
+
+        const invocationOrError = this.buildInvocation(
+          toolInstance,
+          reqInfo.args,
+        );
+        if (invocationOrError instanceof Error) {
+          return {
+            status: 'error',
+            request: reqInfo,
+            tool: toolInstance,
+            response: createErrorResponse(
+              reqInfo,
+              invocationOrError,
+              ToolErrorType.INVALID_TOOL_PARAMS,
+            ),
+            durationMs: 0,
+          };
+        }
+
         return {
           status: 'validating',
           request: reqInfo,
           tool: toolInstance,
+          invocation: invocationOrError,
           startTime: Date.now(),
         };
       },
@@ -465,7 +539,8 @@ export class CoreToolScheduler {
         continue;
       }
 
-      const { request: reqInfo, tool: toolInstance } = toolCall;
+      const { request: reqInfo, invocation } = toolCall;
+
       try {
         if (this.config.getApprovalMode() === ApprovalMode.YOLO) {
           this.setToolCallOutcome(
@@ -474,10 +549,8 @@ export class CoreToolScheduler {
           );
           this.setStatusInternal(reqInfo.callId, 'scheduled');
         } else {
-          const confirmationDetails = await toolInstance.shouldConfirmExecute(
-            reqInfo.args,
-            signal,
-          );
+          const confirmationDetails =
+            await invocation.shouldConfirmExecute(signal);
 
           if (confirmationDetails) {
             // Allow IDE to resolve confirmation
@@ -573,7 +646,7 @@ export class CoreToolScheduler {
       );
     } else if (outcome === ToolConfirmationOutcome.ModifyWithEditor) {
       const waitingToolCall = toolCall as WaitingToolCall;
-      if (isModifiableTool(waitingToolCall.tool)) {
+      if (isModifiableDeclarativeTool(waitingToolCall.tool)) {
         const modifyContext = waitingToolCall.tool.getModifyContext(signal);
         const editorType = this.getPreferredEditor();
         if (!editorType) {
@@ -628,7 +701,7 @@ export class CoreToolScheduler {
   ): Promise<void> {
     if (
       toolCall.confirmationDetails.type !== 'edit' ||
-      !isModifiableTool(toolCall.tool)
+      !isModifiableDeclarativeTool(toolCall.tool)
     ) {
       return;
     }
@@ -677,6 +750,7 @@ export class CoreToolScheduler {
 
         const scheduledCall = toolCall;
         const { callId, name: toolName } = scheduledCall.request;
+        const invocation = scheduledCall.invocation;
         this.setStatusInternal(callId, 'executing');
 
         const liveOutputCallback =
@@ -694,8 +768,8 @@ export class CoreToolScheduler {
               }
             : undefined;
 
-        scheduledCall.tool
-          .execute(scheduledCall.request.args, signal, liveOutputCallback)
+        invocation
+          .execute(signal, liveOutputCallback)
           .then(async (toolResult: ToolResult) => {
             if (signal.aborted) {
               this.setStatusInternal(
diff --git a/packages/core/src/core/nonInteractiveToolExecutor.test.ts b/packages/core/src/core/nonInteractiveToolExecutor.test.ts
index 1bbb9209..b0ed7107 100644
--- a/packages/core/src/core/nonInteractiveToolExecutor.test.ts
+++ b/packages/core/src/core/nonInteractiveToolExecutor.test.ts
@@ -10,12 +10,10 @@ import {
   ToolRegistry,
   ToolCallRequestInfo,
   ToolResult,
-  Tool,
-  ToolCallConfirmationDetails,
   Config,
-  Icon,
 } from '../index.js';
-import { Part, Type } from '@google/genai';
+import { Part } from '@google/genai';
+import { MockTool } from '../test-utils/tools.js';
 
 const mockConfig = {
   getSessionId: () => 'test-session-id',
@@ -25,36 +23,11 @@ const mockConfig = {
 
 describe('executeToolCall', () => {
   let mockToolRegistry: ToolRegistry;
-  let mockTool: Tool;
+  let mockTool: MockTool;
   let abortController: AbortController;
 
   beforeEach(() => {
-    mockTool = {
-      name: 'testTool',
-      displayName: 'Test Tool',
-      description: 'A tool for testing',
-      icon: Icon.Hammer,
-      schema: {
-        name: 'testTool',
-        description: 'A tool for testing',
-        parameters: {
-          type: Type.OBJECT,
-          properties: {
-            param1: { type: Type.STRING },
-          },
-          required: ['param1'],
-        },
-      },
-      execute: vi.fn(),
-      validateToolParams: vi.fn(() => null),
-      shouldConfirmExecute: vi.fn(() =>
-        Promise.resolve(false as false | ToolCallConfirmationDetails),
-      ),
-      isOutputMarkdown: false,
-      canUpdateOutput: false,
-      getDescription: vi.fn(),
-      toolLocations: vi.fn(() => []),
-    };
+    mockTool = new MockTool();
 
     mockToolRegistry = {
       getTool: vi.fn(),
@@ -77,7 +50,7 @@ describe('executeToolCall', () => {
       returnDisplay: 'Success!',
     };
     vi.mocked(mockToolRegistry.getTool).mockReturnValue(mockTool);
-    vi.mocked(mockTool.execute).mockResolvedValue(toolResult);
+    vi.spyOn(mockTool, 'buildAndExecute').mockResolvedValue(toolResult);
 
     const response = await executeToolCall(
       mockConfig,
@@ -87,7 +60,7 @@ describe('executeToolCall', () => {
     );
 
     expect(mockToolRegistry.getTool).toHaveBeenCalledWith('testTool');
-    expect(mockTool.execute).toHaveBeenCalledWith(
+    expect(mockTool.buildAndExecute).toHaveBeenCalledWith(
       request.args,
       abortController.signal,
     );
@@ -149,7 +122,7 @@ describe('executeToolCall', () => {
     };
     const executionError = new Error('Tool execution failed');
     vi.mocked(mockToolRegistry.getTool).mockReturnValue(mockTool);
-    vi.mocked(mockTool.execute).mockRejectedValue(executionError);
+    vi.spyOn(mockTool, 'buildAndExecute').mockRejectedValue(executionError);
 
     const response = await executeToolCall(
       mockConfig,
@@ -183,25 +156,27 @@ describe('executeToolCall', () => {
     const cancellationError = new Error('Operation cancelled');
     vi.mocked(mockToolRegistry.getTool).mockReturnValue(mockTool);
 
-    vi.mocked(mockTool.execute).mockImplementation(async (_args, signal) => {
-      if (signal?.aborted) {
-        return Promise.reject(cancellationError);
-      }
-      return new Promise((_resolve, reject) => {
-        signal?.addEventListener('abort', () => {
-          reject(cancellationError);
+    vi.spyOn(mockTool, 'buildAndExecute').mockImplementation(
+      async (_args, signal) => {
+        if (signal?.aborted) {
+          return Promise.reject(cancellationError);
+        }
+        return new Promise((_resolve, reject) => {
+          signal?.addEventListener('abort', () => {
+            reject(cancellationError);
+          });
+          // Simulate work that might happen if not aborted immediately
+          const timeoutId = setTimeout(
+            () =>
+              reject(
+                new Error('Should have been cancelled if not aborted prior'),
+              ),
+            100,
+          );
+          signal?.addEventListener('abort', () => clearTimeout(timeoutId));
         });
-        // Simulate work that might happen if not aborted immediately
-        const timeoutId = setTimeout(
-          () =>
-            reject(
-              new Error('Should have been cancelled if not aborted prior'),
-            ),
-          100,
-        );
-        signal?.addEventListener('abort', () => clearTimeout(timeoutId));
-      });
-    });
+      },
+    );
 
     abortController.abort(); // Abort before calling
     const response = await executeToolCall(
@@ -232,7 +207,7 @@ describe('executeToolCall', () => {
       returnDisplay: 'Image processed',
     };
     vi.mocked(mockToolRegistry.getTool).mockReturnValue(mockTool);
-    vi.mocked(mockTool.execute).mockResolvedValue(toolResult);
+    vi.spyOn(mockTool, 'buildAndExecute').mockResolvedValue(toolResult);
 
     const response = await executeToolCall(
       mockConfig,
diff --git a/packages/core/src/core/nonInteractiveToolExecutor.ts b/packages/core/src/core/nonInteractiveToolExecutor.ts
index ed235cd3..43061f83 100644
--- a/packages/core/src/core/nonInteractiveToolExecutor.ts
+++ b/packages/core/src/core/nonInteractiveToolExecutor.ts
@@ -65,7 +65,7 @@ export async function executeToolCall(
   try {
     // Directly execute without confirmation or live output handling
     const effectiveAbortSignal = abortSignal ?? new AbortController().signal;
-    const toolResult: ToolResult = await tool.execute(
+    const toolResult: ToolResult = await tool.buildAndExecute(
       toolCallRequest.args,
       effectiveAbortSignal,
       // No live output callback for non-interactive mode
diff --git a/packages/core/src/telemetry/loggers.test.circular.ts b/packages/core/src/telemetry/loggers.test.circular.ts
index 80444a0d..3cf85e46 100644
--- a/packages/core/src/telemetry/loggers.test.circular.ts
+++ b/packages/core/src/telemetry/loggers.test.circular.ts
@@ -14,7 +14,7 @@ import { ToolCallEvent } from './types.js';
 import { Config } from '../config/config.js';
 import { CompletedToolCall } from '../core/coreToolScheduler.js';
 import { ToolCallRequestInfo, ToolCallResponseInfo } from '../core/turn.js';
-import { Tool } from '../tools/tools.js';
+import { MockTool } from '../test-utils/tools.js';
 
 describe('Circular Reference Handling', () => {
   it('should handle circular references in tool function arguments', () => {
@@ -56,11 +56,13 @@ describe('Circular Reference Handling', () => {
       errorType: undefined,
     };
 
+    const tool = new MockTool('mock-tool');
     const mockCompletedToolCall: CompletedToolCall = {
       status: 'success',
       request: mockRequest,
       response: mockResponse,
-      tool: {} as Tool,
+      tool,
+      invocation: tool.build({}),
       durationMs: 100,
     };
 
@@ -104,11 +106,13 @@ describe('Circular Reference Handling', () => {
       errorType: undefined,
     };
 
+    const tool = new MockTool('mock-tool');
     const mockCompletedToolCall: CompletedToolCall = {
       status: 'success',
       request: mockRequest,
       response: mockResponse,
-      tool: {} as Tool,
+      tool,
+      invocation: tool.build({}),
       durationMs: 100,
     };
 
diff --git a/packages/core/src/telemetry/loggers.test.ts b/packages/core/src/telemetry/loggers.test.ts
index 3d8116cc..14de83a9 100644
--- a/packages/core/src/telemetry/loggers.test.ts
+++ b/packages/core/src/telemetry/loggers.test.ts
@@ -5,6 +5,7 @@
  */
 
 import {
+  AnyToolInvocation,
   AuthType,
   CompletedToolCall,
   ContentGeneratorConfig,
@@ -432,6 +433,7 @@ describe('loggers', () => {
     });
 
     it('should log a tool call with all fields', () => {
+      const tool = new EditTool(mockConfig);
       const call: CompletedToolCall = {
         status: 'success',
         request: {
@@ -451,7 +453,8 @@ describe('loggers', () => {
           error: undefined,
           errorType: undefined,
         },
-        tool: new EditTool(mockConfig),
+        tool,
+        invocation: {} as AnyToolInvocation,
         durationMs: 100,
         outcome: ToolConfirmationOutcome.ProceedOnce,
       };
@@ -581,6 +584,7 @@ describe('loggers', () => {
         },
         outcome: ToolConfirmationOutcome.ModifyWithEditor,
         tool: new EditTool(mockConfig),
+        invocation: {} as AnyToolInvocation,
         durationMs: 100,
       };
       const event = new ToolCallEvent(call);
@@ -645,6 +649,7 @@ describe('loggers', () => {
           errorType: undefined,
         },
         tool: new EditTool(mockConfig),
+        invocation: {} as AnyToolInvocation,
         durationMs: 100,
       };
       const event = new ToolCallEvent(call);
diff --git a/packages/core/src/telemetry/uiTelemetry.test.ts b/packages/core/src/telemetry/uiTelemetry.test.ts
index 221804d2..ac9727f1 100644
--- a/packages/core/src/telemetry/uiTelemetry.test.ts
+++ b/packages/core/src/telemetry/uiTelemetry.test.ts
@@ -23,7 +23,8 @@ import {
   SuccessfulToolCall,
 } from '../core/coreToolScheduler.js';
 import { ToolErrorType } from '../tools/tool-error.js';
-import { Tool, ToolConfirmationOutcome } from '../tools/tools.js';
+import { ToolConfirmationOutcome } from '../tools/tools.js';
+import { MockTool } from '../test-utils/tools.js';
 
 const createFakeCompletedToolCall = (
   name: string,
@@ -39,12 +40,14 @@ const createFakeCompletedToolCall = (
     isClientInitiated: false,
     prompt_id: 'prompt-id-1',
   };
+  const tool = new MockTool(name);
 
   if (success) {
     return {
       status: 'success',
       request,
-      tool: { name } as Tool, // Mock tool
+      tool,
+      invocation: tool.build({}),
       response: {
         callId: request.callId,
         responseParts: {
@@ -65,6 +68,7 @@ const createFakeCompletedToolCall = (
     return {
       status: 'error',
       request,
+      tool,
       response: {
         callId: request.callId,
         responseParts: {
diff --git a/packages/core/src/test-utils/tools.ts b/packages/core/src/test-utils/tools.ts
new file mode 100644
index 00000000..b168db9c
--- /dev/null
+++ b/packages/core/src/test-utils/tools.ts
@@ -0,0 +1,63 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { vi } from 'vitest';
+import {
+  BaseTool,
+  Icon,
+  ToolCallConfirmationDetails,
+  ToolResult,
+} from '../tools/tools.js';
+import { Schema, Type } from '@google/genai';
+
+/**
+ * A highly configurable mock tool for testing purposes.
+ */
+export class MockTool extends BaseTool<{ [key: string]: unknown }, ToolResult> {
+  executeFn = vi.fn();
+  shouldConfirm = false;
+
+  constructor(
+    name = 'mock-tool',
+    displayName?: string,
+    description = 'A mock tool for testing.',
+    params: Schema = {
+      type: Type.OBJECT,
+      properties: { param: { type: Type.STRING } },
+    },
+  ) {
+    super(name, displayName ?? name, description, Icon.Hammer, params);
+  }
+
+  async execute(
+    params: { [key: string]: unknown },
+    _abortSignal: AbortSignal,
+  ): Promise<ToolResult> {
+    const result = this.executeFn(params);
+    return (
+      result ?? {
+        llmContent: `Tool ${this.name} executed successfully.`,
+        returnDisplay: `Tool ${this.name} executed successfully.`,
+      }
+    );
+  }
+
+  async shouldConfirmExecute(
+    _params: { [key: string]: unknown },
+    _abortSignal: AbortSignal,
+  ): Promise<ToolCallConfirmationDetails | false> {
+    if (this.shouldConfirm) {
+      return {
+        type: 'exec' as const,
+        title: `Confirm ${this.displayName}`,
+        command: this.name,
+        rootCommand: this.name,
+        onConfirm: async () => {},
+      };
+    }
+    return false;
+  }
+}
diff --git a/packages/core/src/tools/edit.ts b/packages/core/src/tools/edit.ts
index 0d129e42..853ad4c1 100644
--- a/packages/core/src/tools/edit.ts
+++ b/packages/core/src/tools/edit.ts
@@ -26,7 +26,7 @@ import { Config, ApprovalMode } from '../config/config.js';
 import { ensureCorrectEdit } from '../utils/editCorrector.js';
 import { DEFAULT_DIFF_OPTIONS } from './diffOptions.js';
 import { ReadFileTool } from './read-file.js';
-import { ModifiableTool, ModifyContext } from './modifiable-tool.js';
+import { ModifiableDeclarativeTool, ModifyContext } from './modifiable-tool.js';
 
 /**
  * Parameters for the Edit tool
@@ -72,7 +72,7 @@ interface CalculatedEdit {
  */
 export class EditTool
   extends BaseTool<EditToolParams, ToolResult>
-  implements ModifiableTool<EditToolParams>
+  implements ModifiableDeclarativeTool<EditToolParams>
 {
   static readonly Name = 'replace';
 
diff --git a/packages/core/src/tools/memoryTool.ts b/packages/core/src/tools/memoryTool.ts
index 847ea5cf..f3bf315b 100644
--- a/packages/core/src/tools/memoryTool.ts
+++ b/packages/core/src/tools/memoryTool.ts
@@ -18,7 +18,7 @@ import { homedir } from 'os';
 import * as Diff from 'diff';
 import { DEFAULT_DIFF_OPTIONS } from './diffOptions.js';
 import { tildeifyPath } from '../utils/paths.js';
-import { ModifiableTool, ModifyContext } from './modifiable-tool.js';
+import { ModifiableDeclarativeTool, ModifyContext } from './modifiable-tool.js';
 
 const memoryToolSchemaData: FunctionDeclaration = {
   name: 'save_memory',
@@ -112,7 +112,7 @@ function ensureNewlineSeparation(currentContent: string): string {
 
 export class MemoryTool
   extends BaseTool<SaveMemoryParams, ToolResult>
-  implements ModifiableTool<SaveMemoryParams>
+  implements ModifiableDeclarativeTool<SaveMemoryParams>
 {
   private static readonly allowlist: Set<string> = new Set();
 
diff --git a/packages/core/src/tools/modifiable-tool.test.ts b/packages/core/src/tools/modifiable-tool.test.ts
index eb7e8dbf..dc68640a 100644
--- a/packages/core/src/tools/modifiable-tool.test.ts
+++ b/packages/core/src/tools/modifiable-tool.test.ts
@@ -8,8 +8,8 @@ import { vi, describe, it, expect, beforeEach, afterEach } from 'vitest';
 import {
   modifyWithEditor,
   ModifyContext,
-  ModifiableTool,
-  isModifiableTool,
+  ModifiableDeclarativeTool,
+  isModifiableDeclarativeTool,
 } from './modifiable-tool.js';
 import { EditorType } from '../utils/editor.js';
 import fs from 'fs';
@@ -338,16 +338,16 @@ describe('isModifiableTool', () => {
     const mockTool = {
       name: 'test-tool',
       getModifyContext: vi.fn(),
-    } as unknown as ModifiableTool<TestParams>;
+    } as unknown as ModifiableDeclarativeTool<TestParams>;
 
-    expect(isModifiableTool(mockTool)).toBe(true);
+    expect(isModifiableDeclarativeTool(mockTool)).toBe(true);
   });
 
   it('should return false for objects without getModifyContext method', () => {
     const mockTool = {
       name: 'test-tool',
-    } as unknown as ModifiableTool<TestParams>;
+    } as unknown as ModifiableDeclarativeTool<TestParams>;
 
-    expect(isModifiableTool(mockTool)).toBe(false);
+    expect(isModifiableDeclarativeTool(mockTool)).toBe(false);
   });
 });
diff --git a/packages/core/src/tools/modifiable-tool.ts b/packages/core/src/tools/modifiable-tool.ts
index 42de3eb6..25a2906b 100644
--- a/packages/core/src/tools/modifiable-tool.ts
+++ b/packages/core/src/tools/modifiable-tool.ts
@@ -11,13 +11,14 @@ import fs from 'fs';
 import * as Diff from 'diff';
 import { DEFAULT_DIFF_OPTIONS } from './diffOptions.js';
 import { isNodeError } from '../utils/errors.js';
-import { Tool } from './tools.js';
+import { AnyDeclarativeTool, DeclarativeTool, ToolResult } from './tools.js';
 
 /**
- * A tool that supports a modify operation.
+ * A declarative tool that supports a modify operation.
  */
-export interface ModifiableTool<ToolParams> extends Tool<ToolParams> {
-  getModifyContext(abortSignal: AbortSignal): ModifyContext<ToolParams>;
+export interface ModifiableDeclarativeTool<TParams extends object>
+  extends DeclarativeTool<TParams, ToolResult> {
+  getModifyContext(abortSignal: AbortSignal): ModifyContext<TParams>;
 }
 
 export interface ModifyContext<ToolParams> {
@@ -39,9 +40,12 @@ export interface ModifyResult<ToolParams> {
   updatedDiff: string;
 }
 
-export function isModifiableTool<TParams>(
-  tool: Tool<TParams>,
-): tool is ModifiableTool<TParams> {
+/**
+ * Type guard to check if a declarative tool is modifiable.
+ */
+export function isModifiableDeclarativeTool(
+  tool: AnyDeclarativeTool,
+): tool is ModifiableDeclarativeTool<object> {
   return 'getModifyContext' in tool;
 }
 
diff --git a/packages/core/src/tools/read-file.test.ts b/packages/core/src/tools/read-file.test.ts
index fa1e458c..bb9317fd 100644
--- a/packages/core/src/tools/read-file.test.ts
+++ b/packages/core/src/tools/read-file.test.ts
@@ -13,6 +13,7 @@ import fsp from 'fs/promises';
 import { Config } from '../config/config.js';
 import { FileDiscoveryService } from '../services/fileDiscoveryService.js';
 import { createMockWorkspaceContext } from '../test-utils/mockWorkspaceContext.js';
+import { ToolInvocation, ToolResult } from './tools.js';
 
 describe('ReadFileTool', () => {
   let tempRootDir: string;
@@ -40,57 +41,62 @@ describe('ReadFileTool', () => {
     }
   });
 
-  describe('validateToolParams', () => {
-    it('should return null for valid params (absolute path within root)', () => {
+  describe('build', () => {
+    it('should return an invocation for valid params (absolute path within root)', () => {
       const params: ReadFileToolParams = {
         absolute_path: path.join(tempRootDir, 'test.txt'),
       };
-      expect(tool.validateToolParams(params)).toBeNull();
+      const result = tool.build(params);
+      expect(result).not.toBeTypeOf('string');
+      expect(typeof result).toBe('object');
+      expect(
+        (result as ToolInvocation<ReadFileToolParams, ToolResult>).params,
+      ).toEqual(params);
     });
 
-    it('should return null for valid params with offset and limit', () => {
+    it('should return an invocation for valid params with offset and limit', () => {
       const params: ReadFileToolParams = {
         absolute_path: path.join(tempRootDir, 'test.txt'),
         offset: 0,
         limit: 10,
       };
-      expect(tool.validateToolParams(params)).toBeNull();
+      const result = tool.build(params);
+      expect(result).not.toBeTypeOf('string');
     });
 
-    it('should return error for relative path', () => {
+    it('should throw error for relative path', () => {
       const params: ReadFileToolParams = { absolute_path: 'test.txt' };
-      expect(tool.validateToolParams(params)).toBe(
+      expect(() => tool.build(params)).toThrow(
         `File path must be absolute, but was relative: test.txt. You must provide an absolute path.`,
       );
     });
 
-    it('should return error for path outside root', () => {
+    it('should throw error for path outside root', () => {
       const outsidePath = path.resolve(os.tmpdir(), 'outside-root.txt');
       const params: ReadFileToolParams = { absolute_path: outsidePath };
-      const error = tool.validateToolParams(params);
-      expect(error).toContain(
+      expect(() => tool.build(params)).toThrow(
         'File path must be within one of the workspace directories',
       );
     });
 
-    it('should return error for negative offset', () => {
+    it('should throw error for negative offset', () => {
       const params: ReadFileToolParams = {
         absolute_path: path.join(tempRootDir, 'test.txt'),
         offset: -1,
         limit: 10,
       };
-      expect(tool.validateToolParams(params)).toBe(
+      expect(() => tool.build(params)).toThrow(
         'Offset must be a non-negative number',
       );
     });
 
-    it('should return error for non-positive limit', () => {
+    it('should throw error for non-positive limit', () => {
       const paramsZero: ReadFileToolParams = {
         absolute_path: path.join(tempRootDir, 'test.txt'),
         offset: 0,
         limit: 0,
       };
-      expect(tool.validateToolParams(paramsZero)).toBe(
+      expect(() => tool.build(paramsZero)).toThrow(
         'Limit must be a positive number',
       );
       const paramsNegative: ReadFileToolParams = {
@@ -98,168 +104,182 @@ describe('ReadFileTool', () => {
         offset: 0,
         limit: -5,
       };
-      expect(tool.validateToolParams(paramsNegative)).toBe(
+      expect(() => tool.build(paramsNegative)).toThrow(
         'Limit must be a positive number',
       );
     });
 
-    it('should return error for schema validation failure (e.g. missing path)', () => {
+    it('should throw error for schema validation failure (e.g. missing path)', () => {
       const params = { offset: 0 } as unknown as ReadFileToolParams;
-      expect(tool.validateToolParams(params)).toBe(
+      expect(() => tool.build(params)).toThrow(
         `params must have required property 'absolute_path'`,
       );
     });
   });
 
-  describe('getDescription', () => {
-    it('should return a shortened, relative path', () => {
-      const filePath = path.join(tempRootDir, 'sub', 'dir', 'file.txt');
-      const params: ReadFileToolParams = { absolute_path: filePath };
-      expect(tool.getDescription(params)).toBe(
-        path.join('sub', 'dir', 'file.txt'),
-      );
-    });
+  describe('ToolInvocation', () => {
+    describe('getDescription', () => {
+      it('should return a shortened, relative path', () => {
+        const filePath = path.join(tempRootDir, 'sub', 'dir', 'file.txt');
+        const params: ReadFileToolParams = { absolute_path: filePath };
+        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 };
-      expect(tool.getDescription(params)).toBe('.');
-    });
-  });
-
-  describe('execute', () => {
-    it('should return validation error if params are invalid', async () => {
-      const params: ReadFileToolParams = {
-        absolute_path: 'relative/path.txt',
-      };
-      expect(await tool.execute(params, abortSignal)).toEqual({
-        llmContent:
-          'Error: Invalid parameters provided. Reason: File path must be absolute, but was relative: relative/path.txt. You must provide an absolute path.',
-        returnDisplay:
-          'File path must be absolute, but was relative: relative/path.txt. You must provide an absolute path.',
+      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('.');
       });
     });
 
-    it('should return error if file does not exist', async () => {
-      const filePath = path.join(tempRootDir, 'nonexistent.txt');
-      const params: ReadFileToolParams = { absolute_path: filePath };
+    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
+        >;
 
-      expect(await tool.execute(params, abortSignal)).toEqual({
-        llmContent: `File not found: ${filePath}`,
-        returnDisplay: '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 };
-
-      expect(await tool.execute(params, abortSignal)).toEqual({
-        llmContent: fileContent,
-        returnDisplay: '',
-      });
-    });
-
-    it('should return success result for an image file', async () => {
-      // A minimal 1x1 transparent PNG file.
-      const pngContent = Buffer.from([
-        137, 80, 78, 71, 13, 10, 26, 10, 0, 0, 0, 13, 73, 72, 68, 82, 0, 0, 0,
-        1, 0, 0, 0, 1, 8, 6, 0, 0, 0, 31, 21, 196, 137, 0, 0, 0, 10, 73, 68, 65,
-        84, 120, 156, 99, 0, 1, 0, 0, 5, 0, 1, 13, 10, 45, 180, 0, 0, 0, 0, 73,
-        69, 78, 68, 174, 66, 96, 130,
-      ]);
-      const filePath = path.join(tempRootDir, 'image.png');
-      await fsp.writeFile(filePath, pngContent);
-      const params: ReadFileToolParams = { absolute_path: filePath };
-
-      expect(await tool.execute(params, abortSignal)).toEqual({
-        llmContent: {
-          inlineData: {
-            mimeType: 'image/png',
-            data: pngContent.toString('base64'),
-          },
-        },
-        returnDisplay: `Read image file: image.png`,
-      });
-    });
-
-    it('should treat a non-image file with image extension as an image', async () => {
-      const filePath = path.join(tempRootDir, 'fake-image.png');
-      const fileContent = 'This is not a real png.';
-      await fsp.writeFile(filePath, fileContent, 'utf-8');
-      const params: ReadFileToolParams = { absolute_path: filePath };
-
-      expect(await tool.execute(params, abortSignal)).toEqual({
-        llmContent: {
-          inlineData: {
-            mimeType: 'image/png',
-            data: Buffer.from(fileContent).toString('base64'),
-          },
-        },
-        returnDisplay: `Read image file: fake-image.png`,
-      });
-    });
-
-    it('should pass offset and limit to read a slice of a text file', async () => {
-      const filePath = path.join(tempRootDir, 'paginated.txt');
-      const fileContent = Array.from(
-        { length: 20 },
-        (_, i) => `Line ${i + 1}`,
-      ).join('\n');
-      await fsp.writeFile(filePath, fileContent, 'utf-8');
-
-      const params: ReadFileToolParams = {
-        absolute_path: filePath,
-        offset: 5, // Start from line 6
-        limit: 3,
-      };
-
-      expect(await tool.execute(params, abortSignal)).toEqual({
-        llmContent: [
-          '[File content truncated: showing lines 6-8 of 20 total lines. Use offset/limit parameters to view more.]',
-          'Line 6',
-          'Line 7',
-          'Line 8',
-        ].join('\n'),
-        returnDisplay: '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 return 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(await tool.execute(params, abortSignal)).toEqual({
-          llmContent: `Error: Invalid parameters provided. Reason: ${expectedError}`,
-          returnDisplay: expectedError,
+        expect(await invocation.execute(abortSignal)).toEqual({
+          llmContent: `File not found: ${filePath}`,
+          returnDisplay: 'File not found.',
         });
       });
 
-      it('should return error if path is in an ignored directory', async () => {
-        const ignoredDirPath = path.join(tempRootDir, 'ignored');
-        await fsp.mkdir(ignoredDirPath);
-        const filePath = path.join(ignoredDirPath, 'somefile.txt');
-        await fsp.writeFile(filePath, 'content', 'utf-8');
+      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 success result for an image file', async () => {
+        // A minimal 1x1 transparent PNG file.
+        const pngContent = Buffer.from([
+          137, 80, 78, 71, 13, 10, 26, 10, 0, 0, 0, 13, 73, 72, 68, 82, 0, 0, 0,
+          1, 0, 0, 0, 1, 8, 6, 0, 0, 0, 31, 21, 196, 137, 0, 0, 0, 10, 73, 68,
+          65, 84, 120, 156, 99, 0, 1, 0, 0, 5, 0, 1, 13, 10, 45, 180, 0, 0, 0,
+          0, 73, 69, 78, 68, 174, 66, 96, 130,
+        ]);
+        const filePath = path.join(tempRootDir, 'image.png');
+        await fsp.writeFile(filePath, pngContent);
+        const params: ReadFileToolParams = { absolute_path: filePath };
+        const invocation = tool.build(params) as ToolInvocation<
+          ReadFileToolParams,
+          ToolResult
+        >;
+
+        expect(await invocation.execute(abortSignal)).toEqual({
+          llmContent: {
+            inlineData: {
+              mimeType: 'image/png',
+              data: pngContent.toString('base64'),
+            },
+          },
+          returnDisplay: `Read image file: image.png`,
+        });
+      });
+
+      it('should treat a non-image file with image extension as an image', async () => {
+        const filePath = path.join(tempRootDir, 'fake-image.png');
+        const fileContent = 'This is not a real png.';
+        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: {
+            inlineData: {
+              mimeType: 'image/png',
+              data: Buffer.from(fileContent).toString('base64'),
+            },
+          },
+          returnDisplay: `Read image file: fake-image.png`,
+        });
+      });
+
+      it('should pass offset and limit to read a slice of a text file', async () => {
+        const filePath = path.join(tempRootDir, 'paginated.txt');
+        const fileContent = Array.from(
+          { length: 20 },
+          (_, i) => `Line ${i + 1}`,
+        ).join('\n');
+        await fsp.writeFile(filePath, fileContent, 'utf-8');
 
         const params: ReadFileToolParams = {
           absolute_path: filePath,
+          offset: 5, // Start from line 6
+          limit: 3,
         };
-        const expectedError = `File path '${filePath}' is ignored by .geminiignore pattern(s).`;
-        expect(await tool.execute(params, abortSignal)).toEqual({
-          llmContent: `Error: Invalid parameters provided. Reason: ${expectedError}`,
-          returnDisplay: expectedError,
+        const invocation = tool.build(params) as ToolInvocation<
+          ReadFileToolParams,
+          ToolResult
+        >;
+
+        expect(await invocation.execute(abortSignal)).toEqual({
+          llmContent: [
+            '[File content truncated: showing lines 6-8 of 20 total lines. Use offset/limit parameters to view more.]',
+            'Line 6',
+            'Line 7',
+            'Line 8',
+          ].join('\n'),
+          returnDisplay: '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 path is in an ignored directory', async () => {
+          const ignoredDirPath = path.join(tempRootDir, 'ignored');
+          await fsp.mkdir(ignoredDirPath);
+          const filePath = path.join(ignoredDirPath, 'somefile.txt');
+          await fsp.writeFile(filePath, 'content', 'utf-8');
+
+          const params: ReadFileToolParams = {
+            absolute_path: filePath,
+          };
+          const expectedError = `File path '${filePath}' is ignored by .geminiignore pattern(s).`;
+          expect(() => tool.build(params)).toThrow(expectedError);
         });
       });
     });
@@ -270,18 +290,16 @@ describe('ReadFileTool', () => {
       const params: ReadFileToolParams = {
         absolute_path: path.join(tempRootDir, 'file.txt'),
       };
-      expect(tool.validateToolParams(params)).toBeNull();
+      expect(() => tool.build(params)).not.toThrow();
     });
 
     it('should reject paths outside workspace root', () => {
       const params: ReadFileToolParams = {
         absolute_path: '/etc/passwd',
       };
-      const error = tool.validateToolParams(params);
-      expect(error).toContain(
+      expect(() => tool.build(params)).toThrow(
         'File path must be within one of the workspace directories',
       );
-      expect(error).toContain(tempRootDir);
     });
 
     it('should provide clear error message with workspace directories', () => {
@@ -289,11 +307,9 @@ describe('ReadFileTool', () => {
       const params: ReadFileToolParams = {
         absolute_path: outsidePath,
       };
-      const error = tool.validateToolParams(params);
-      expect(error).toContain(
+      expect(() => tool.build(params)).toThrow(
         'File path must be within one of the workspace directories',
       );
-      expect(error).toContain(tempRootDir);
     });
   });
 });
diff --git a/packages/core/src/tools/read-file.ts b/packages/core/src/tools/read-file.ts
index 31282c20..3a05da06 100644
--- a/packages/core/src/tools/read-file.ts
+++ b/packages/core/src/tools/read-file.ts
@@ -7,7 +7,13 @@
 import path from 'path';
 import { SchemaValidator } from '../utils/schemaValidator.js';
 import { makeRelative, shortenPath } from '../utils/paths.js';
-import { BaseTool, Icon, ToolLocation, ToolResult } from './tools.js';
+import {
+  BaseDeclarativeTool,
+  Icon,
+  ToolInvocation,
+  ToolLocation,
+  ToolResult,
+} from './tools.js';
 import { Type } from '@google/genai';
 import {
   processSingleFileContent,
@@ -39,10 +45,72 @@ export interface ReadFileToolParams {
   limit?: number;
 }
 
+class ReadFileToolInvocation
+  implements ToolInvocation<ReadFileToolParams, ToolResult>
+{
+  constructor(
+    private config: Config,
+    public params: ReadFileToolParams,
+  ) {}
+
+  getDescription(): string {
+    const relativePath = makeRelative(
+      this.params.absolute_path,
+      this.config.getTargetDir(),
+    );
+    return shortenPath(relativePath);
+  }
+
+  toolLocations(): ToolLocation[] {
+    return [{ path: this.params.absolute_path, line: this.params.offset }];
+  }
+
+  shouldConfirmExecute(): Promise<false> {
+    return Promise.resolve(false);
+  }
+
+  async execute(): Promise<ToolResult> {
+    const result = await processSingleFileContent(
+      this.params.absolute_path,
+      this.config.getTargetDir(),
+      this.params.offset,
+      this.params.limit,
+    );
+
+    if (result.error) {
+      return {
+        llmContent: result.error, // The detailed error for LLM
+        returnDisplay: result.returnDisplay || 'Error reading file', // User-friendly error
+      };
+    }
+
+    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: result.llmContent || '',
+      returnDisplay: result.returnDisplay || '',
+    };
+  }
+}
+
 /**
  * Implementation of the ReadFile tool logic
  */
-export class ReadFileTool extends BaseTool<ReadFileToolParams, ToolResult> {
+export class ReadFileTool extends BaseDeclarativeTool<
+  ReadFileToolParams,
+  ToolResult
+> {
   static readonly Name: string = 'read_file';
 
   constructor(private config: Config) {
@@ -75,7 +143,7 @@ export class ReadFileTool extends BaseTool<ReadFileToolParams, ToolResult> {
     );
   }
 
-  validateToolParams(params: ReadFileToolParams): string | null {
+  protected validateToolParams(params: ReadFileToolParams): string | null {
     const errors = SchemaValidator.validate(this.schema.parameters, params);
     if (errors) {
       return errors;
@@ -106,67 +174,9 @@ export class ReadFileTool extends BaseTool<ReadFileToolParams, ToolResult> {
     return null;
   }
 
-  getDescription(params: ReadFileToolParams): string {
-    if (
-      !params ||
-      typeof params.absolute_path !== 'string' ||
-      params.absolute_path.trim() === ''
-    ) {
-      return `Path unavailable`;
-    }
-    const relativePath = makeRelative(
-      params.absolute_path,
-      this.config.getTargetDir(),
-    );
-    return shortenPath(relativePath);
-  }
-
-  toolLocations(params: ReadFileToolParams): ToolLocation[] {
-    return [{ path: params.absolute_path, line: params.offset }];
-  }
-
-  async execute(
+  protected createInvocation(
     params: ReadFileToolParams,
-    _signal: AbortSignal,
-  ): Promise<ToolResult> {
-    const validationError = this.validateToolParams(params);
-    if (validationError) {
-      return {
-        llmContent: `Error: Invalid parameters provided. Reason: ${validationError}`,
-        returnDisplay: validationError,
-      };
-    }
-
-    const result = await processSingleFileContent(
-      params.absolute_path,
-      this.config.getTargetDir(),
-      params.offset,
-      params.limit,
-    );
-
-    if (result.error) {
-      return {
-        llmContent: result.error, // The detailed error for LLM
-        returnDisplay: result.returnDisplay || 'Error reading file', // User-friendly error
-      };
-    }
-
-    const lines =
-      typeof result.llmContent === 'string'
-        ? result.llmContent.split('\n').length
-        : undefined;
-    const mimetype = getSpecificMimeType(params.absolute_path);
-    recordFileOperationMetric(
-      this.config,
-      FileOperation.READ,
-      lines,
-      mimetype,
-      path.extname(params.absolute_path),
-    );
-
-    return {
-      llmContent: result.llmContent || '',
-      returnDisplay: result.returnDisplay || '',
-    };
+  ): ToolInvocation<ReadFileToolParams, ToolResult> {
+    return new ReadFileToolInvocation(this.config, params);
   }
 }
diff --git a/packages/core/src/tools/tool-registry.test.ts b/packages/core/src/tools/tool-registry.test.ts
index 24b6ca5f..e7c71e14 100644
--- a/packages/core/src/tools/tool-registry.test.ts
+++ b/packages/core/src/tools/tool-registry.test.ts
@@ -21,7 +21,6 @@ import {
   sanitizeParameters,
 } from './tool-registry.js';
 import { DiscoveredMCPTool } from './mcp-tool.js';
-import { BaseTool, Icon, ToolResult } from './tools.js';
 import {
   FunctionDeclaration,
   CallableTool,
@@ -32,6 +31,7 @@ import {
 import { spawn } from 'node:child_process';
 
 import fs from 'node:fs';
+import { MockTool } from '../test-utils/tools.js';
 
 vi.mock('node:fs');
 
@@ -107,28 +107,6 @@ const createMockCallableTool = (
   callTool: vi.fn(),
 });
 
-class MockTool extends BaseTool<{ param: string }, ToolResult> {
-  constructor(
-    name = 'mock-tool',
-    displayName = 'A mock tool',
-    description = 'A mock tool description',
-  ) {
-    super(name, displayName, description, Icon.Hammer, {
-      type: Type.OBJECT,
-      properties: {
-        param: { type: Type.STRING },
-      },
-      required: ['param'],
-    });
-  }
-  async execute(params: { param: string }): Promise<ToolResult> {
-    return {
-      llmContent: `Executed with ${params.param}`,
-      returnDisplay: `Executed with ${params.param}`,
-    };
-  }
-}
-
 const baseConfigParams: ConfigParameters = {
   cwd: '/tmp',
   model: 'test-model',
diff --git a/packages/core/src/tools/tool-registry.ts b/packages/core/src/tools/tool-registry.ts
index e60b8f74..73b427d4 100644
--- a/packages/core/src/tools/tool-registry.ts
+++ b/packages/core/src/tools/tool-registry.ts
@@ -5,7 +5,7 @@
  */
 
 import { FunctionDeclaration, Schema, Type } from '@google/genai';
-import { Tool, ToolResult, BaseTool, Icon } from './tools.js';
+import { AnyDeclarativeTool, Icon, ToolResult, BaseTool } from './tools.js';
 import { Config } from '../config/config.js';
 import { spawn } from 'node:child_process';
 import { StringDecoder } from 'node:string_decoder';
@@ -125,7 +125,7 @@ Signal: Signal number or \`(none)\` if no signal was received.
 }
 
 export class ToolRegistry {
-  private tools: Map<string, Tool> = new Map();
+  private tools: Map<string, AnyDeclarativeTool> = new Map();
   private config: Config;
 
   constructor(config: Config) {
@@ -136,7 +136,7 @@ export class ToolRegistry {
    * Registers a tool definition.
    * @param tool - The tool object containing schema and execution logic.
    */
-  registerTool(tool: Tool): void {
+  registerTool(tool: AnyDeclarativeTool): void {
     if (this.tools.has(tool.name)) {
       if (tool instanceof DiscoveredMCPTool) {
         tool = tool.asFullyQualifiedTool();
@@ -368,7 +368,7 @@ export class ToolRegistry {
   /**
    * Returns an array of all registered and discovered tool instances.
    */
-  getAllTools(): Tool[] {
+  getAllTools(): AnyDeclarativeTool[] {
     return Array.from(this.tools.values()).sort((a, b) =>
       a.displayName.localeCompare(b.displayName),
     );
@@ -377,8 +377,8 @@ export class ToolRegistry {
   /**
    * Returns an array of tools registered from a specific MCP server.
    */
-  getToolsByServer(serverName: string): Tool[] {
-    const serverTools: Tool[] = [];
+  getToolsByServer(serverName: string): AnyDeclarativeTool[] {
+    const serverTools: AnyDeclarativeTool[] = [];
     for (const tool of this.tools.values()) {
       if ((tool as DiscoveredMCPTool)?.serverName === serverName) {
         serverTools.push(tool);
@@ -390,7 +390,7 @@ export class ToolRegistry {
   /**
    * Get the definition of a specific tool.
    */
-  getTool(name: string): Tool | undefined {
+  getTool(name: string): AnyDeclarativeTool | undefined {
     return this.tools.get(name);
   }
 }
diff --git a/packages/core/src/tools/tools.ts b/packages/core/src/tools/tools.ts
index 3404093f..79e6f010 100644
--- a/packages/core/src/tools/tools.ts
+++ b/packages/core/src/tools/tools.ts
@@ -9,101 +9,243 @@ import { ToolErrorType } from './tool-error.js';
 import { DiffUpdateResult } from '../ide/ideContext.js';
 
 /**
- * Interface representing the base Tool functionality
+ * Represents a validated and ready-to-execute tool call.
+ * An instance of this is created by a `ToolBuilder`.
  */
-export interface Tool<
-  TParams = unknown,
-  TResult extends ToolResult = ToolResult,
+export interface ToolInvocation<
+  TParams extends object,
+  TResult extends ToolResult,
 > {
   /**
-   * The internal name of the tool (used for API calls)
+   * The validated parameters for this specific invocation.
    */
-  name: string;
+  params: TParams;
 
   /**
-   * The user-friendly display name of the tool
+   * Gets a pre-execution description of the tool operation.
+   * @returns A markdown string describing what the tool will do.
    */
-  displayName: string;
+  getDescription(): string;
 
   /**
-   * Description of what the tool does
+   * Determines what file system paths the tool will affect.
+   * @returns A list of such paths.
    */
-  description: string;
+  toolLocations(): ToolLocation[];
 
   /**
-   * The icon to display when interacting via ACP
-   */
-  icon: Icon;
-
-  /**
-   * Function declaration schema from @google/genai
-   */
-  schema: FunctionDeclaration;
-
-  /**
-   * Whether the tool's output should be rendered as markdown
-   */
-  isOutputMarkdown: boolean;
-
-  /**
-   * Whether the tool supports live (streaming) output
-   */
-  canUpdateOutput: boolean;
-
-  /**
-   * Validates the parameters for the tool
-   * Should be called from both `shouldConfirmExecute` and `execute`
-   * `shouldConfirmExecute` should return false immediately if invalid
-   * @param params Parameters to validate
-   * @returns An error message string if invalid, null otherwise
-   */
-  validateToolParams(params: TParams): string | null;
-
-  /**
-   * Gets a pre-execution description of the tool operation
-   * @param params Parameters for the tool execution
-   * @returns A markdown string describing what the tool will do
-   * Optional for backward compatibility
-   */
-  getDescription(params: TParams): string;
-
-  /**
-   * Determines what file system paths the tool will affect
-   * @param params Parameters for the tool execution
-   * @returns A list of such paths
-   */
-  toolLocations(params: TParams): ToolLocation[];
-
-  /**
-   * Determines if the tool should prompt for confirmation before execution
-   * @param params Parameters for the tool execution
-   * @returns Whether execute should be confirmed.
+   * Determines if the tool should prompt for confirmation before execution.
+   * @returns Confirmation details or false if no confirmation is needed.
    */
   shouldConfirmExecute(
-    params: TParams,
     abortSignal: AbortSignal,
   ): Promise<ToolCallConfirmationDetails | false>;
 
   /**
-   * Executes the tool with the given parameters
-   * @param params Parameters for the tool execution
-   * @returns Result of the tool execution
+   * Executes the tool with the validated parameters.
+   * @param signal AbortSignal for tool cancellation.
+   * @param updateOutput Optional callback to stream output.
+   * @returns Result of the tool execution.
    */
   execute(
-    params: TParams,
     signal: AbortSignal,
     updateOutput?: (output: string) => void,
   ): Promise<TResult>;
 }
 
+/**
+ * A type alias for a tool invocation where the specific parameter and result types are not known.
+ */
+export type AnyToolInvocation = ToolInvocation<object, ToolResult>;
+
+/**
+ * An adapter that wraps the legacy `Tool` interface to make it compatible
+ * with the new `ToolInvocation` pattern.
+ */
+export class LegacyToolInvocation<
+  TParams extends object,
+  TResult extends ToolResult,
+> implements ToolInvocation<TParams, TResult>
+{
+  constructor(
+    private readonly legacyTool: BaseTool<TParams, TResult>,
+    readonly params: TParams,
+  ) {}
+
+  getDescription(): string {
+    return this.legacyTool.getDescription(this.params);
+  }
+
+  toolLocations(): ToolLocation[] {
+    return this.legacyTool.toolLocations(this.params);
+  }
+
+  shouldConfirmExecute(
+    abortSignal: AbortSignal,
+  ): Promise<ToolCallConfirmationDetails | false> {
+    return this.legacyTool.shouldConfirmExecute(this.params, abortSignal);
+  }
+
+  execute(
+    signal: AbortSignal,
+    updateOutput?: (output: string) => void,
+  ): Promise<TResult> {
+    return this.legacyTool.execute(this.params, signal, updateOutput);
+  }
+}
+
+/**
+ * Interface for a tool builder that validates parameters and creates invocations.
+ */
+export interface ToolBuilder<
+  TParams extends object,
+  TResult extends ToolResult,
+> {
+  /**
+   * The internal name of the tool (used for API calls).
+   */
+  name: string;
+
+  /**
+   * The user-friendly display name of the tool.
+   */
+  displayName: string;
+
+  /**
+   * Description of what the tool does.
+   */
+  description: string;
+
+  /**
+   * The icon to display when interacting via ACP.
+   */
+  icon: Icon;
+
+  /**
+   * Function declaration schema from @google/genai.
+   */
+  schema: FunctionDeclaration;
+
+  /**
+   * Whether the tool's output should be rendered as markdown.
+   */
+  isOutputMarkdown: boolean;
+
+  /**
+   * Whether the tool supports live (streaming) output.
+   */
+  canUpdateOutput: boolean;
+
+  /**
+   * Validates raw parameters and builds a ready-to-execute invocation.
+   * @param params The raw, untrusted parameters from the model.
+   * @returns A valid `ToolInvocation` if successful. Throws an error if validation fails.
+   */
+  build(params: TParams): ToolInvocation<TParams, TResult>;
+}
+
+/**
+ * New base class for tools that separates validation from execution.
+ * New tools should extend this class.
+ */
+export abstract class DeclarativeTool<
+  TParams extends object,
+  TResult extends ToolResult,
+> implements ToolBuilder<TParams, TResult>
+{
+  constructor(
+    readonly name: string,
+    readonly displayName: string,
+    readonly description: string,
+    readonly icon: Icon,
+    readonly parameterSchema: Schema,
+    readonly isOutputMarkdown: boolean = true,
+    readonly canUpdateOutput: boolean = false,
+  ) {}
+
+  get schema(): FunctionDeclaration {
+    return {
+      name: this.name,
+      description: this.description,
+      parameters: this.parameterSchema,
+    };
+  }
+
+  /**
+   * Validates the raw tool parameters.
+   * Subclasses should override this to add custom validation logic
+   * beyond the JSON schema check.
+   * @param params The raw parameters from the model.
+   * @returns An error message string if invalid, null otherwise.
+   */
+  protected validateToolParams(_params: TParams): string | null {
+    // Base implementation can be extended by subclasses.
+    return null;
+  }
+
+  /**
+   * The core of the new pattern. It validates parameters and, if successful,
+   * returns a `ToolInvocation` object that encapsulates the logic for the
+   * specific, validated call.
+   * @param params The raw, untrusted parameters from the model.
+   * @returns A `ToolInvocation` instance.
+   */
+  abstract build(params: TParams): ToolInvocation<TParams, TResult>;
+
+  /**
+   * A convenience method that builds and executes the tool in one step.
+   * Throws an error if validation fails.
+   * @param params The raw, untrusted parameters from the model.
+   * @param signal AbortSignal for tool cancellation.
+   * @param updateOutput Optional callback to stream output.
+   * @returns The result of the tool execution.
+   */
+  async buildAndExecute(
+    params: TParams,
+    signal: AbortSignal,
+    updateOutput?: (output: string) => void,
+  ): Promise<TResult> {
+    const invocation = this.build(params);
+    return invocation.execute(signal, updateOutput);
+  }
+}
+
+/**
+ * New base class for declarative tools that separates validation from execution.
+ * New tools should extend this class, which provides a `build` method that
+ * validates parameters before deferring to a `createInvocation` method for
+ * the final `ToolInvocation` object instantiation.
+ */
+export abstract class BaseDeclarativeTool<
+  TParams extends object,
+  TResult extends ToolResult,
+> extends DeclarativeTool<TParams, TResult> {
+  build(params: TParams): ToolInvocation<TParams, TResult> {
+    const validationError = this.validateToolParams(params);
+    if (validationError) {
+      throw new Error(validationError);
+    }
+    return this.createInvocation(params);
+  }
+
+  protected abstract createInvocation(
+    params: TParams,
+  ): ToolInvocation<TParams, TResult>;
+}
+
+/**
+ * A type alias for a declarative tool where the specific parameter and result types are not known.
+ */
+export type AnyDeclarativeTool = DeclarativeTool<object, ToolResult>;
+
 /**
  * Base implementation for tools with common functionality
+ * @deprecated Use `DeclarativeTool` for new tools.
  */
 export abstract class BaseTool<
-  TParams = unknown,
+  TParams extends object,
   TResult extends ToolResult = ToolResult,
-> implements Tool<TParams, TResult>
-{
+> extends DeclarativeTool<TParams, TResult> {
   /**
    * Creates a new instance of BaseTool
    * @param name Internal name of the tool (used for API calls)
@@ -121,17 +263,24 @@ export abstract class BaseTool<
     readonly parameterSchema: Schema,
     readonly isOutputMarkdown: boolean = true,
     readonly canUpdateOutput: boolean = false,
-  ) {}
+  ) {
+    super(
+      name,
+      displayName,
+      description,
+      icon,
+      parameterSchema,
+      isOutputMarkdown,
+      canUpdateOutput,
+    );
+  }
 
-  /**
-   * Function declaration schema computed from name, description, and parameterSchema
-   */
-  get schema(): FunctionDeclaration {
-    return {
-      name: this.name,
-      description: this.description,
-      parameters: this.parameterSchema,
-    };
+  build(params: TParams): ToolInvocation<TParams, TResult> {
+    const validationError = this.validateToolParams(params);
+    if (validationError) {
+      throw new Error(validationError);
+    }
+    return new LegacyToolInvocation(this, params);
   }
 
   /**
diff --git a/packages/core/src/tools/write-file.ts b/packages/core/src/tools/write-file.ts
index 32ecc068..9e7e3813 100644
--- a/packages/core/src/tools/write-file.ts
+++ b/packages/core/src/tools/write-file.ts
@@ -26,7 +26,7 @@ import {
   ensureCorrectFileContent,
 } from '../utils/editCorrector.js';
 import { DEFAULT_DIFF_OPTIONS } from './diffOptions.js';
-import { ModifiableTool, ModifyContext } from './modifiable-tool.js';
+import { ModifiableDeclarativeTool, ModifyContext } from './modifiable-tool.js';
 import { getSpecificMimeType } from '../utils/fileUtils.js';
 import {
   recordFileOperationMetric,
@@ -66,7 +66,7 @@ interface GetCorrectedFileContentResult {
  */
 export class WriteFileTool
   extends BaseTool<WriteFileToolParams, ToolResult>
-  implements ModifiableTool<WriteFileToolParams>
+  implements ModifiableDeclarativeTool<WriteFileToolParams>
 {
   static readonly Name: string = 'write_file';
 

From 1f0ad865444c07481385c39b272f9ec2b94d41b9 Mon Sep 17 00:00:00 2001
From: shishu314 <shishu_1998@yahoo.com>
Date: Wed, 6 Aug 2025 15:19:10 -0400
Subject: [PATCH 017/107] fix: Restore user input when the user cancels
 response (#5601)

Co-authored-by: Shi Shu <shii@google.com>
Co-authored-by: Jacob Richman <jacob314@gmail.com>
---
 packages/cli/src/ui/App.tsx                   | 29 +++++---
 .../cli/src/ui/hooks/useGeminiStream.test.tsx | 66 +++++++++++++++++++
 packages/cli/src/ui/hooks/useGeminiStream.ts  |  2 +
 3 files changed, 87 insertions(+), 10 deletions(-)

diff --git a/packages/cli/src/ui/App.tsx b/packages/cli/src/ui/App.tsx
index 66396c36..f2dcc79e 100644
--- a/packages/cli/src/ui/App.tsx
+++ b/packages/cli/src/ui/App.tsx
@@ -486,6 +486,24 @@ const App = ({ config, settings, startupWarnings = [], version }: AppProps) => {
     setGeminiMdFileCount,
   );
 
+  const buffer = useTextBuffer({
+    initialText: '',
+    viewport: { height: 10, width: inputWidth },
+    stdin,
+    setRawMode,
+    isValidPath,
+    shellModeActive,
+  });
+
+  const [userMessages, setUserMessages] = useState<string[]>([]);
+
+  const handleUserCancel = useCallback(() => {
+    const lastUserMessage = userMessages.at(-1);
+    if (lastUserMessage) {
+      buffer.setText(lastUserMessage);
+    }
+  }, [buffer, userMessages]);
+
   const {
     streamingState,
     submitQuery,
@@ -506,6 +524,7 @@ const App = ({ config, settings, startupWarnings = [], version }: AppProps) => {
     modelSwitchedFromQuotaError,
     setModelSwitchedFromQuotaError,
     refreshStatic,
+    handleUserCancel,
   );
 
   // Input handling
@@ -519,15 +538,6 @@ const App = ({ config, settings, startupWarnings = [], version }: AppProps) => {
     [submitQuery],
   );
 
-  const buffer = useTextBuffer({
-    initialText: '',
-    viewport: { height: 10, width: inputWidth },
-    stdin,
-    setRawMode,
-    isValidPath,
-    shellModeActive,
-  });
-
   const { handleInput: vimHandleInput } = useVim(buffer, handleFinalSubmit);
   const pendingHistoryItems = [...pendingSlashCommandHistoryItems];
   pendingHistoryItems.push(...pendingGeminiHistoryItems);
@@ -607,7 +617,6 @@ const App = ({ config, settings, startupWarnings = [], version }: AppProps) => {
   }, [config, config.getGeminiMdFileCount]);
 
   const logger = useLogger();
-  const [userMessages, setUserMessages] = useState<string[]>([]);
 
   useEffect(() => {
     const fetchUserMessages = async () => {
diff --git a/packages/cli/src/ui/hooks/useGeminiStream.test.tsx b/packages/cli/src/ui/hooks/useGeminiStream.test.tsx
index dd2428bb..751b869e 100644
--- a/packages/cli/src/ui/hooks/useGeminiStream.test.tsx
+++ b/packages/cli/src/ui/hooks/useGeminiStream.test.tsx
@@ -406,6 +406,8 @@ describe('useGeminiStream', () => {
           () => Promise.resolve(),
           false,
           () => {},
+          () => {},
+          () => {},
         );
       },
       {
@@ -560,6 +562,8 @@ describe('useGeminiStream', () => {
         () => Promise.resolve(),
         false,
         () => {},
+        () => {},
+        () => {},
       ),
     );
 
@@ -633,6 +637,8 @@ describe('useGeminiStream', () => {
         () => Promise.resolve(),
         false,
         () => {},
+        () => {},
+        () => {},
       ),
     );
 
@@ -737,6 +743,8 @@ describe('useGeminiStream', () => {
         () => Promise.resolve(),
         false,
         () => {},
+        () => {},
+        () => {},
       ),
     );
 
@@ -843,6 +851,8 @@ describe('useGeminiStream', () => {
         () => Promise.resolve(),
         false,
         () => {},
+        () => {},
+        () => {},
       ),
     );
 
@@ -943,6 +953,44 @@ describe('useGeminiStream', () => {
       expect(result.current.streamingState).toBe(StreamingState.Idle);
     });
 
+    it('should call onCancelSubmit handler when escape is pressed', async () => {
+      const cancelSubmitSpy = vi.fn();
+      const mockStream = (async function* () {
+        yield { type: 'content', value: 'Part 1' };
+        // Keep the stream open
+        await new Promise(() => {});
+      })();
+      mockSendMessageStream.mockReturnValue(mockStream);
+
+      const { result } = renderHook(() =>
+        useGeminiStream(
+          mockConfig.getGeminiClient(),
+          [],
+          mockAddItem,
+          mockConfig,
+          mockOnDebugMessage,
+          mockHandleSlashCommand,
+          false,
+          () => 'vscode' as EditorType,
+          () => {},
+          () => Promise.resolve(),
+          false,
+          () => {},
+          () => {},
+          cancelSubmitSpy,
+        ),
+      );
+
+      // Start a query
+      await act(async () => {
+        result.current.submitQuery('test query');
+      });
+
+      simulateEscapeKeyPress();
+
+      expect(cancelSubmitSpy).toHaveBeenCalled();
+    });
+
     it('should not do anything if escape is pressed when not responding', () => {
       const { result } = renderTestHook();
 
@@ -1202,6 +1250,8 @@ describe('useGeminiStream', () => {
           mockPerformMemoryRefresh,
           false,
           () => {},
+          () => {},
+          () => {},
         ),
       );
 
@@ -1253,6 +1303,8 @@ describe('useGeminiStream', () => {
           () => Promise.resolve(),
           false,
           () => {},
+          () => {},
+          () => {},
         ),
       );
 
@@ -1301,6 +1353,8 @@ describe('useGeminiStream', () => {
           () => Promise.resolve(),
           false,
           () => {},
+          () => {},
+          () => {},
         ),
       );
 
@@ -1347,6 +1401,8 @@ describe('useGeminiStream', () => {
           () => Promise.resolve(),
           false,
           () => {},
+          () => {},
+          () => {},
         ),
       );
 
@@ -1394,6 +1450,8 @@ describe('useGeminiStream', () => {
           () => Promise.resolve(),
           false,
           () => {},
+          () => {},
+          () => {},
         ),
       );
 
@@ -1481,6 +1539,8 @@ describe('useGeminiStream', () => {
             () => Promise.resolve(),
             false,
             () => {},
+            () => {},
+            () => {},
           ),
         );
 
@@ -1535,6 +1595,8 @@ describe('useGeminiStream', () => {
           () => Promise.resolve(),
           false,
           () => {},
+          () => {},
+          () => {},
         ),
       );
 
@@ -1611,6 +1673,8 @@ describe('useGeminiStream', () => {
           () => Promise.resolve(),
           false,
           () => {},
+          () => {},
+          () => {},
         ),
       );
 
@@ -1663,6 +1727,8 @@ describe('useGeminiStream', () => {
           () => Promise.resolve(),
           false,
           () => {},
+          () => {},
+          () => {},
         ),
       );
 
diff --git a/packages/cli/src/ui/hooks/useGeminiStream.ts b/packages/cli/src/ui/hooks/useGeminiStream.ts
index 63ba961f..58bec431 100644
--- a/packages/cli/src/ui/hooks/useGeminiStream.ts
+++ b/packages/cli/src/ui/hooks/useGeminiStream.ts
@@ -94,6 +94,7 @@ export const useGeminiStream = (
   modelSwitchedFromQuotaError: boolean,
   setModelSwitchedFromQuotaError: React.Dispatch<React.SetStateAction<boolean>>,
   onEditorClose: () => void,
+  onCancelSubmit: () => void,
 ) => {
   const [initError, setInitError] = useState<string | null>(null);
   const abortControllerRef = useRef<AbortController | null>(null);
@@ -200,6 +201,7 @@ export const useGeminiStream = (
         Date.now(),
       );
       setPendingHistoryItem(null);
+      onCancelSubmit();
       setIsResponding(false);
     }
   });

From 1fb680baccf93fee5c96167da96fd31e4d57cf6f Mon Sep 17 00:00:00 2001
From: Lee James <40045512+leehagoodjames@users.noreply.github.com>
Date: Wed, 6 Aug 2025 15:26:46 -0400
Subject: [PATCH 018/107] bug(tests): fix test errors (#5678)

Co-authored-by: matt korwel <matt.korwel@gmail.com>
---
 eslint.config.js | 1 +
 package.json     | 2 +-
 2 files changed, 2 insertions(+), 1 deletion(-)

diff --git a/eslint.config.js b/eslint.config.js
index a1194df7..e639e689 100644
--- a/eslint.config.js
+++ b/eslint.config.js
@@ -35,6 +35,7 @@ export default tseslint.config(
       'packages/vscode-ide-companion/dist/**',
       'bundle/**',
       'package/bundle/**',
+      '.integration-tests/**',
     ],
   },
   eslint.configs.recommended,
diff --git a/package.json b/package.json
index bb7896c5..17442eaa 100644
--- a/package.json
+++ b/package.json
@@ -29,7 +29,7 @@
     "build:packages": "npm run build --workspaces",
     "build:sandbox": "node scripts/build_sandbox.js --skip-npm-install-build",
     "bundle": "npm run generate && node esbuild.config.js && node scripts/copy_bundle_assets.js",
-    "test": "npm run test --workspaces",
+    "test": "npm run test --workspaces --if-present",
     "test:ci": "npm run test:ci --workspaces --if-present && npm run test:scripts",
     "test:scripts": "vitest run --config ./scripts/tests/vitest.config.ts",
     "test:e2e": "npm run test:integration:sandbox:none -- --verbose --keep-output",

From 024b8207eb75bdc0c031f6380d6759b9e342e502 Mon Sep 17 00:00:00 2001
From: Shreya Keshive <skeshive@gmail.com>
Date: Wed, 6 Aug 2025 15:47:58 -0400
Subject: [PATCH 019/107] Add hint to enable IDE integration for users running
 in VS Code (#5610)

---
 packages/cli/src/config/settings.ts           |  3 +
 packages/cli/src/ui/App.test.tsx              |  8 +-
 packages/cli/src/ui/App.tsx                   | 45 ++++++++-
 packages/cli/src/ui/IdeIntegrationNudge.tsx   | 70 +++++++++++++
 packages/vscode-ide-companion/package.json    |  4 +-
 .../src/extension.test.ts                     | 99 +++++++++++++++++++
 .../vscode-ide-companion/src/extension.ts     | 20 ++++
 7 files changed, 244 insertions(+), 5 deletions(-)
 create mode 100644 packages/cli/src/ui/IdeIntegrationNudge.tsx
 create mode 100644 packages/vscode-ide-companion/src/extension.test.ts

diff --git a/packages/cli/src/config/settings.ts b/packages/cli/src/config/settings.ts
index bb8c87b8..93641ae0 100644
--- a/packages/cli/src/config/settings.ts
+++ b/packages/cli/src/config/settings.ts
@@ -115,6 +115,9 @@ export interface Settings {
   /// IDE mode setting configured via slash command toggle.
   ideMode?: boolean;
 
+  // Setting to track if the user has seen the IDE integration nudge.
+  hasSeenIdeIntegrationNudge?: boolean;
+
   // Setting for disabling auto-update.
   disableAutoUpdate?: boolean;
 
diff --git a/packages/cli/src/ui/App.test.tsx b/packages/cli/src/ui/App.test.tsx
index fc6dbb5a..a5c2a9c6 100644
--- a/packages/cli/src/ui/App.test.tsx
+++ b/packages/cli/src/ui/App.test.tsx
@@ -16,6 +16,7 @@ import {
   SandboxConfig,
   GeminiClient,
   ideContext,
+  type AuthType,
 } from '@google/gemini-cli-core';
 import { LoadedSettings, SettingsFile, Settings } from '../config/settings.js';
 import process from 'node:process';
@@ -84,6 +85,7 @@ interface MockServerConfig {
   getAllGeminiMdFilenames: Mock<() => string[]>;
   getGeminiClient: Mock<() => GeminiClient | undefined>;
   getUserTier: Mock<() => Promise<string | undefined>>;
+  getIdeClient: Mock<() => { getCurrentIde: Mock<() => string | undefined> }>;
 }
 
 // Mock @google/gemini-cli-core and its Config class
@@ -157,6 +159,9 @@ vi.mock('@google/gemini-cli-core', async (importOriginal) => {
         getWorkspaceContext: vi.fn(() => ({
           getDirectories: vi.fn(() => []),
         })),
+        getIdeClient: vi.fn(() => ({
+          getCurrentIde: vi.fn(() => 'vscode'),
+        })),
       };
     });
 
@@ -182,6 +187,7 @@ vi.mock('./hooks/useGeminiStream', () => ({
     submitQuery: vi.fn(),
     initError: null,
     pendingHistoryItems: [],
+    thought: null,
   })),
 }));
 
@@ -233,7 +239,7 @@ vi.mock('./utils/updateCheck.js', () => ({
   checkForUpdates: vi.fn(),
 }));
 
-vi.mock('./config/auth.js', () => ({
+vi.mock('../config/auth.js', () => ({
   validateAuthMethod: vi.fn(),
 }));
 
diff --git a/packages/cli/src/ui/App.tsx b/packages/cli/src/ui/App.tsx
index f2dcc79e..2be681e5 100644
--- a/packages/cli/src/ui/App.tsx
+++ b/packages/cli/src/ui/App.tsx
@@ -39,7 +39,7 @@ import { EditorSettingsDialog } from './components/EditorSettingsDialog.js';
 import { ShellConfirmationDialog } from './components/ShellConfirmationDialog.js';
 import { Colors } from './colors.js';
 import { loadHierarchicalGeminiMemory } from '../config/config.js';
-import { LoadedSettings } from '../config/settings.js';
+import { LoadedSettings, SettingScope } from '../config/settings.js';
 import { Tips } from './components/Tips.js';
 import { ConsolePatcher } from './utils/ConsolePatcher.js';
 import { registerCleanup } from '../utils/cleanup.js';
@@ -62,6 +62,10 @@ import {
   type IdeContext,
   ideContext,
 } from '@google/gemini-cli-core';
+import {
+  IdeIntegrationNudge,
+  IdeIntegrationNudgeResult,
+} from './IdeIntegrationNudge.js';
 import { validateAuthMethod } from '../config/auth.js';
 import { useLogger } from './hooks/useLogger.js';
 import { StreamingContext } from './contexts/StreamingContext.js';
@@ -115,6 +119,15 @@ const App = ({ config, settings, startupWarnings = [], version }: AppProps) => {
   const nightly = version.includes('nightly');
   const { history, addItem, clearItems, loadHistory } = useHistory();
 
+  const [idePromptAnswered, setIdePromptAnswered] = useState(false);
+  const currentIDE = config.getIdeClient().getCurrentIde();
+  const shouldShowIdePrompt =
+    config.getIdeModeFeature() &&
+    currentIDE &&
+    !config.getIdeMode() &&
+    !settings.merged.hasSeenIdeIntegrationNudge &&
+    !idePromptAnswered;
+
   useEffect(() => {
     const cleanup = setUpdateHandler(addItem, setUpdateInfo);
     return cleanup;
@@ -538,6 +551,27 @@ const App = ({ config, settings, startupWarnings = [], version }: AppProps) => {
     [submitQuery],
   );
 
+  const handleIdePromptComplete = useCallback(
+    (result: IdeIntegrationNudgeResult) => {
+      if (result === 'yes') {
+        handleSlashCommand('/ide install');
+        settings.setValue(
+          SettingScope.User,
+          'hasSeenIdeIntegrationNudge',
+          true,
+        );
+      } else if (result === 'dismiss') {
+        settings.setValue(
+          SettingScope.User,
+          'hasSeenIdeIntegrationNudge',
+          true,
+        );
+      }
+      setIdePromptAnswered(true);
+    },
+    [handleSlashCommand, settings],
+  );
+
   const { handleInput: vimHandleInput } = useVim(buffer, handleFinalSubmit);
   const pendingHistoryItems = [...pendingSlashCommandHistoryItems];
   pendingHistoryItems.push(...pendingGeminiHistoryItems);
@@ -768,6 +802,7 @@ const App = ({ config, settings, startupWarnings = [], version }: AppProps) => {
       </Box>
     );
   }
+
   const mainAreaWidth = Math.floor(terminalWidth * 0.9);
   const debugConsoleMaxHeight = Math.floor(Math.max(terminalHeight * 0.2, 5));
   // Arbitrary threshold to ensure that items in the static area are large
@@ -859,7 +894,13 @@ const App = ({ config, settings, startupWarnings = [], version }: AppProps) => {
             </Box>
           )}
 
-          {shellConfirmationRequest ? (
+          {shouldShowIdePrompt ? (
+            <IdeIntegrationNudge
+              question="Do you want to connect your VS Code editor to Gemini CLI?"
+              description="If you select Yes, we'll install an extension that allows the CLI to access your open files and display diffs directly in VS Code."
+              onComplete={handleIdePromptComplete}
+            />
+          ) : shellConfirmationRequest ? (
             <ShellConfirmationDialog request={shellConfirmationRequest} />
           ) : isThemeDialogOpen ? (
             <Box flexDirection="column">
diff --git a/packages/cli/src/ui/IdeIntegrationNudge.tsx b/packages/cli/src/ui/IdeIntegrationNudge.tsx
new file mode 100644
index 00000000..72cd1756
--- /dev/null
+++ b/packages/cli/src/ui/IdeIntegrationNudge.tsx
@@ -0,0 +1,70 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { Box, Text, useInput } from 'ink';
+import {
+  RadioButtonSelect,
+  RadioSelectItem,
+} from './components/shared/RadioButtonSelect.js';
+
+export type IdeIntegrationNudgeResult = 'yes' | 'no' | 'dismiss';
+
+interface IdeIntegrationNudgeProps {
+  question: string;
+  description?: string;
+  onComplete: (result: IdeIntegrationNudgeResult) => void;
+}
+
+export function IdeIntegrationNudge({
+  question,
+  description,
+  onComplete,
+}: IdeIntegrationNudgeProps) {
+  useInput((_input, key) => {
+    if (key.escape) {
+      onComplete('no');
+    }
+  });
+
+  const OPTIONS: Array<RadioSelectItem<IdeIntegrationNudgeResult>> = [
+    {
+      label: 'Yes',
+      value: 'yes',
+    },
+    {
+      label: 'No (esc)',
+      value: 'no',
+    },
+    {
+      label: "No, don't ask again",
+      value: 'dismiss',
+    },
+  ];
+
+  return (
+    <Box
+      flexDirection="column"
+      borderStyle="round"
+      borderColor="yellow"
+      padding={1}
+      width="100%"
+      marginLeft={1}
+    >
+      <Box marginBottom={1} flexDirection="column">
+        <Text>
+          <Text color="yellow">{'> '}</Text>
+          {question}
+        </Text>
+        {description && <Text dimColor>{description}</Text>}
+      </Box>
+      <RadioButtonSelect
+        items={OPTIONS}
+        onSelect={onComplete}
+        isFocused={true}
+      />
+    </Box>
+  );
+}
diff --git a/packages/vscode-ide-companion/package.json b/packages/vscode-ide-companion/package.json
index 263f1b18..aee14e32 100644
--- a/packages/vscode-ide-companion/package.json
+++ b/packages/vscode-ide-companion/package.json
@@ -39,12 +39,12 @@
     "commands": [
       {
         "command": "gemini.diff.accept",
-        "title": "Gemini CLI: Accept Current Diff",
+        "title": "Gemini CLI: Accept Diff",
         "icon": "$(check)"
       },
       {
         "command": "gemini.diff.cancel",
-        "title": "Cancel",
+        "title": "Gemini CLI: Close Diff Editor",
         "icon": "$(close)"
       },
       {
diff --git a/packages/vscode-ide-companion/src/extension.test.ts b/packages/vscode-ide-companion/src/extension.test.ts
new file mode 100644
index 00000000..89d1821f
--- /dev/null
+++ b/packages/vscode-ide-companion/src/extension.test.ts
@@ -0,0 +1,99 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import * as vscode from 'vscode';
+import { activate } from './extension.js';
+
+vi.mock('vscode', () => ({
+  window: {
+    createOutputChannel: vi.fn(() => ({
+      appendLine: vi.fn(),
+    })),
+    showInformationMessage: vi.fn(),
+    createTerminal: vi.fn(() => ({
+      show: vi.fn(),
+      sendText: vi.fn(),
+    })),
+  },
+  workspace: {
+    workspaceFolders: [],
+    onDidCloseTextDocument: vi.fn(),
+    registerTextDocumentContentProvider: vi.fn(),
+    onDidChangeWorkspaceFolders: vi.fn(),
+  },
+  commands: {
+    registerCommand: vi.fn(),
+    executeCommand: vi.fn(),
+  },
+  Uri: {
+    joinPath: vi.fn(),
+  },
+  ExtensionMode: {
+    Development: 1,
+    Production: 2,
+  },
+  EventEmitter: vi.fn(() => ({
+    event: vi.fn(),
+    fire: vi.fn(),
+    dispose: vi.fn(),
+  })),
+}));
+
+describe('activate', () => {
+  let context: vscode.ExtensionContext;
+
+  beforeEach(() => {
+    context = {
+      subscriptions: [],
+      environmentVariableCollection: {
+        replace: vi.fn(),
+      },
+      globalState: {
+        get: vi.fn(),
+        update: vi.fn(),
+      },
+      extensionUri: {
+        fsPath: '/path/to/extension',
+      },
+    } as unknown as vscode.ExtensionContext;
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it('should show the info message on first activation', async () => {
+    const showInformationMessageMock = vi
+      .mocked(vscode.window.showInformationMessage)
+      .mockResolvedValue(undefined as never);
+    vi.mocked(context.globalState.get).mockReturnValue(undefined);
+    await activate(context);
+    expect(showInformationMessageMock).toHaveBeenCalledWith(
+      'Gemini CLI Companion extension successfully installed. Please restart your terminal to enable full IDE integration.',
+      'Re-launch Gemini CLI',
+    );
+  });
+
+  it('should not show the info message on subsequent activations', async () => {
+    vi.mocked(context.globalState.get).mockReturnValue(true);
+    await activate(context);
+    expect(vscode.window.showInformationMessage).not.toHaveBeenCalled();
+  });
+
+  it('should launch the Gemini CLI when the user clicks the button', async () => {
+    const showInformationMessageMock = vi
+      .mocked(vscode.window.showInformationMessage)
+      .mockResolvedValue('Re-launch Gemini CLI' as never);
+    vi.mocked(context.globalState.get).mockReturnValue(undefined);
+    await activate(context);
+    expect(showInformationMessageMock).toHaveBeenCalled();
+    await new Promise(process.nextTick); // Wait for the promise to resolve
+    expect(vscode.commands.executeCommand).toHaveBeenCalledWith(
+      'gemini-cli.runGeminiCLI',
+    );
+  });
+});
diff --git a/packages/vscode-ide-companion/src/extension.ts b/packages/vscode-ide-companion/src/extension.ts
index b31e15b8..08389731 100644
--- a/packages/vscode-ide-companion/src/extension.ts
+++ b/packages/vscode-ide-companion/src/extension.ts
@@ -9,6 +9,7 @@ import { IDEServer } from './ide-server.js';
 import { DiffContentProvider, DiffManager } from './diff-manager.js';
 import { createLogger } from './utils/logger.js';
 
+const INFO_MESSAGE_SHOWN_KEY = 'geminiCliInfoMessageShown';
 const IDE_WORKSPACE_PATH_ENV_VAR = 'GEMINI_CLI_IDE_WORKSPACE_PATH';
 export const DIFF_SCHEME = 'gemini-diff';
 
@@ -81,6 +82,25 @@ export async function activate(context: vscode.ExtensionContext) {
     log(`Failed to start IDE server: ${message}`);
   }
 
+  if (!context.globalState.get(INFO_MESSAGE_SHOWN_KEY)) {
+    void vscode.window
+      .showInformationMessage(
+        'Gemini CLI Companion extension successfully installed. Please restart your terminal to enable full IDE integration.',
+        'Re-launch Gemini CLI',
+      )
+      .then(
+        (selection) => {
+          if (selection === 'Re-launch Gemini CLI') {
+            void vscode.commands.executeCommand('gemini-cli.runGeminiCLI');
+          }
+        },
+        (err) => {
+          log(`Failed to show information message: ${String(err)}`);
+        },
+      );
+    context.globalState.update(INFO_MESSAGE_SHOWN_KEY, true);
+  }
+
   context.subscriptions.push(
     vscode.workspace.onDidChangeWorkspaceFolders(() => {
       updateWorkspacePath(context);

From b3cfaeb6d30101262dc2b7350f5a349cd0417386 Mon Sep 17 00:00:00 2001
From: Jacob MacDonald <jakemac@google.com>
Date: Wed, 6 Aug 2025 13:19:15 -0700
Subject: [PATCH 020/107] Add detection of tools with bad schemas and
 automatically omit them with a warning (#5694)

---
 packages/core/src/tools/mcp-client.test.ts | 336 +++++++++++++++++++++
 packages/core/src/tools/mcp-client.ts      |  68 +++++
 2 files changed, 404 insertions(+)

diff --git a/packages/core/src/tools/mcp-client.test.ts b/packages/core/src/tools/mcp-client.test.ts
index 9997d60e..1ccba76a 100644
--- a/packages/core/src/tools/mcp-client.test.ts
+++ b/packages/core/src/tools/mcp-client.test.ts
@@ -12,6 +12,7 @@ import {
   isEnabled,
   discoverTools,
   discoverPrompts,
+  hasValidTypes,
 } from './mcp-client.js';
 import { SSEClientTransport } from '@modelcontextprotocol/sdk/client/sse.js';
 import * as SdkClientStdioLib from '@modelcontextprotocol/sdk/client/stdio.js';
@@ -97,6 +98,182 @@ describe('mcp-client', () => {
         `Error discovering tool: 'invalid tool name' from MCP server 'test-server': ${testError.message}`,
       );
     });
+
+    it('should skip tools if a parameter is missing a type', async () => {
+      const mockedClient = {} as unknown as ClientLib.Client;
+      const consoleWarnSpy = vi
+        .spyOn(console, 'warn')
+        .mockImplementation(() => {});
+      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 tools = await discoverTools('test-server', {}, mockedClient);
+
+      expect(tools.length).toBe(1);
+      expect(vi.mocked(DiscoveredMCPTool).mock.calls[0][2]).toBe('validTool');
+      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 skip tools if a nested parameter is missing a type', async () => {
+      const mockedClient = {} as unknown as ClientLib.Client;
+      const consoleWarnSpy = vi
+        .spyOn(console, 'warn')
+        .mockImplementation(() => {});
+      vi.mocked(GenAiLib.mcpToTool).mockReturnValue({
+        tool: () =>
+          Promise.resolve({
+            functionDeclarations: [
+              {
+                name: 'invalidTool',
+                parametersJsonSchema: {
+                  type: 'object',
+                  properties: {
+                    param1: {
+                      type: 'object',
+                      properties: {
+                        nestedParam: {
+                          description: 'a nested param with no type',
+                        },
+                      },
+                    },
+                  },
+                },
+              },
+            ],
+          }),
+      } as unknown as GenAiLib.CallableTool);
+
+      const tools = await discoverTools('test-server', {}, mockedClient);
+
+      expect(tools.length).toBe(0);
+      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 skip tool if an array item is missing a type', async () => {
+      const mockedClient = {} as unknown as ClientLib.Client;
+      const consoleWarnSpy = vi
+        .spyOn(console, 'warn')
+        .mockImplementation(() => {});
+      vi.mocked(GenAiLib.mcpToTool).mockReturnValue({
+        tool: () =>
+          Promise.resolve({
+            functionDeclarations: [
+              {
+                name: 'invalidTool',
+                parametersJsonSchema: {
+                  type: 'object',
+                  properties: {
+                    param1: {
+                      type: 'array',
+                      items: {
+                        description: 'an array item with no type',
+                      },
+                    },
+                  },
+                },
+              },
+            ],
+          }),
+      } as unknown as GenAiLib.CallableTool);
+
+      const tools = await discoverTools('test-server', {}, mockedClient);
+
+      expect(tools.length).toBe(0);
+      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 discover tool with no properties in schema', async () => {
+      const mockedClient = {} as unknown as ClientLib.Client;
+      const consoleWarnSpy = vi
+        .spyOn(console, 'warn')
+        .mockImplementation(() => {});
+      vi.mocked(GenAiLib.mcpToTool).mockReturnValue({
+        tool: () =>
+          Promise.resolve({
+            functionDeclarations: [
+              {
+                name: 'validTool',
+                parametersJsonSchema: {
+                  type: 'object',
+                },
+              },
+            ],
+          }),
+      } as unknown as GenAiLib.CallableTool);
+
+      const tools = await discoverTools('test-server', {}, mockedClient);
+
+      expect(tools.length).toBe(1);
+      expect(vi.mocked(DiscoveredMCPTool).mock.calls[0][2]).toBe('validTool');
+      expect(consoleWarnSpy).not.toHaveBeenCalled();
+      consoleWarnSpy.mockRestore();
+    });
+
+    it('should discover tool with empty properties object in schema', async () => {
+      const mockedClient = {} as unknown as ClientLib.Client;
+      const consoleWarnSpy = vi
+        .spyOn(console, 'warn')
+        .mockImplementation(() => {});
+      vi.mocked(GenAiLib.mcpToTool).mockReturnValue({
+        tool: () =>
+          Promise.resolve({
+            functionDeclarations: [
+              {
+                name: 'validTool',
+                parametersJsonSchema: {
+                  type: 'object',
+                  properties: {},
+                },
+              },
+            ],
+          }),
+      } as unknown as GenAiLib.CallableTool);
+
+      const tools = await discoverTools('test-server', {}, mockedClient);
+
+      expect(tools.length).toBe(1);
+      expect(vi.mocked(DiscoveredMCPTool).mock.calls[0][2]).toBe('validTool');
+      expect(consoleWarnSpy).not.toHaveBeenCalled();
+      consoleWarnSpy.mockRestore();
+    });
   });
 
   describe('discoverPrompts', () => {
@@ -433,4 +610,163 @@ describe('mcp-client', () => {
       );
     });
   });
+
+  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);
+    });
+  });
 });
diff --git a/packages/core/src/tools/mcp-client.ts b/packages/core/src/tools/mcp-client.ts
index 26244d9e..9a35b84e 100644
--- a/packages/core/src/tools/mcp-client.ts
+++ b/packages/core/src/tools/mcp-client.ts
@@ -416,6 +416,65 @@ export async function connectAndDiscover(
   }
 }
 
+/**
+ * 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,
@@ -448,6 +507,15 @@ export async function discoverTools(
           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,

From e3e76777535da2817b5fcac012456db29147059e Mon Sep 17 00:00:00 2001
From: Jacob MacDonald <jakemac@google.com>
Date: Wed, 6 Aug 2025 13:45:54 -0700
Subject: [PATCH 021/107] Add integration test for maximum schema depth error
 handling (#5685)

---
 eslint.config.js                              |   1 +
 .../mcp_server_cyclic_schema.test.js          | 206 ++++++++++++++++++
 integration-tests/test-helper.js              |   5 +
 packages/core/src/core/geminiChat.ts          |  32 ++-
 4 files changed, 227 insertions(+), 17 deletions(-)
 create mode 100644 integration-tests/mcp_server_cyclic_schema.test.js

diff --git a/eslint.config.js b/eslint.config.js
index e639e689..f35d4f35 100644
--- a/eslint.config.js
+++ b/eslint.config.js
@@ -28,6 +28,7 @@ export default tseslint.config(
     // Global ignores
     ignores: [
       'node_modules/*',
+      '.integration-tests/**',
       'eslint.config.js',
       'packages/cli/dist/**',
       'packages/core/dist/**',
diff --git a/integration-tests/mcp_server_cyclic_schema.test.js b/integration-tests/mcp_server_cyclic_schema.test.js
new file mode 100644
index 00000000..a78e0922
--- /dev/null
+++ b/integration-tests/mcp_server_cyclic_schema.test.js
@@ -0,0 +1,206 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * This test verifies we can match maximum schema depth errors from Gemini
+ * and then detect and warn about the potential tools that caused the error.
+ */
+
+import { test, describe, before } from 'node:test';
+import { strict as assert } from 'node:assert';
+import { TestRig } from './test-helper.js';
+import { join } from 'path';
+import { fileURLToPath } from 'url';
+import { writeFileSync, readFileSync } from 'fs';
+
+const __dirname = fileURLToPath(new URL('.', import.meta.url));
+
+// Create a minimal MCP server that doesn't require external dependencies
+// This implements the MCP protocol directly using Node.js built-ins
+const serverScript = `#!/usr/bin/env node
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+const readline = require('readline');
+const fs = require('fs');
+
+// Debug logging to stderr (only when MCP_DEBUG or VERBOSE is set)
+const debugEnabled = process.env.MCP_DEBUG === 'true' || process.env.VERBOSE === 'true';
+function debug(msg) {
+  if (debugEnabled) {
+    fs.writeSync(2, \`[MCP-DEBUG] \${msg}\\n\`);
+  }
+}
+
+debug('MCP server starting...');
+
+// Simple JSON-RPC implementation for MCP
+class SimpleJSONRPC {
+  constructor() {
+    this.handlers = new Map();
+    this.rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout,
+      terminal: false
+    });
+
+    this.rl.on('line', (line) => {
+      debug(\`Received line: \${line}\`);
+      try {
+        const message = JSON.parse(line);
+        debug(\`Parsed message: \${JSON.stringify(message)}\`);
+        this.handleMessage(message);
+      } catch (e) {
+        debug(\`Parse error: \${e.message}\`);
+      }
+    });
+  }
+
+  send(message) {
+    const msgStr = JSON.stringify(message);
+    debug(\`Sending message: \${msgStr}\`);
+    process.stdout.write(msgStr + '\\n');
+  }
+
+  async handleMessage(message) {
+    if (message.method && this.handlers.has(message.method)) {
+      try {
+        const result = await this.handlers.get(message.method)(message.params || {});
+        if (message.id !== undefined) {
+          this.send({
+            jsonrpc: '2.0',
+            id: message.id,
+            result
+          });
+        }
+      } catch (error) {
+        if (message.id !== undefined) {
+          this.send({
+            jsonrpc: '2.0',
+            id: message.id,
+            error: {
+              code: -32603,
+              message: error.message
+            }
+          });
+        }
+      }
+    } else if (message.id !== undefined) {
+      this.send({
+        jsonrpc: '2.0',
+        id: message.id,
+        error: {
+          code: -32601,
+          message: 'Method not found'
+        }
+      });
+    }
+  }
+
+  on(method, handler) {
+    this.handlers.set(method, handler);
+  }
+}
+
+// Create MCP server
+const rpc = new SimpleJSONRPC();
+
+// Handle initialize
+rpc.on('initialize', async (params) => {
+  debug('Handling initialize request');
+  return {
+    protocolVersion: '2024-11-05',
+    capabilities: {
+      tools: {}
+    },
+    serverInfo: {
+      name: 'cyclic-schema-server',
+      version: '1.0.0'
+    }
+  };
+});
+
+// Handle tools/list
+rpc.on('tools/list', async () => {
+  debug('Handling tools/list request');
+  return {
+    tools: [{
+      name: 'tool_with_cyclic_schema',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          data: {
+            type: 'array',
+            items: {
+              type: 'object',
+              properties: {
+                child: { $ref: '#/properties/data/items' },
+              },
+            },
+          },
+        },
+      }
+    }]
+  };
+});
+
+// Send initialization notification
+rpc.send({
+  jsonrpc: '2.0',
+  method: 'initialized'
+});
+`;
+
+describe('mcp server with cyclic tool schema is detected', () => {
+  const rig = new TestRig();
+
+  before(async () => {
+    // Setup test directory with MCP server configuration
+    await rig.setup('cyclic-schema-mcp-server', {
+      settings: {
+        mcpServers: {
+          'cyclic-schema-server': {
+            command: 'node',
+            args: ['mcp-server.cjs'],
+          },
+        },
+      },
+    });
+
+    // Create server script in the test directory
+    const testServerPath = join(rig.testDir, 'mcp-server.cjs');
+    writeFileSync(testServerPath, serverScript);
+
+    // Make the script executable (though running with 'node' should work anyway)
+    if (process.platform !== 'win32') {
+      const { chmodSync } = await import('fs');
+      chmodSync(testServerPath, 0o755);
+    }
+  });
+
+  test('should error and suggest disabling the cyclic tool', async () => {
+    // Just run any command to trigger the schema depth error.
+    // If this test starts failing, check `isSchemaDepthError` from
+    // geminiChat.ts to see if it needs to be updated.
+    // Or, possibly it could mean that gemini has fixed the issue.
+    const output = await rig.run('hello');
+
+    // The error message is in a log file, so we need to extract the path and read it.
+    const match = output.match(/Full report available at: (.*\.json)/);
+    assert(match, `Could not find log file path in output: ${output}`);
+
+    const logFilePath = match[1];
+    const logFileContent = readFileSync(logFilePath, 'utf-8');
+
+    assert.match(
+      logFileContent,
+      / - tool_with_cyclic_schema \(cyclic-schema-server MCP Server\)/,
+    );
+  });
+});
diff --git a/integration-tests/test-helper.js b/integration-tests/test-helper.js
index 9526ea5f..e4d55631 100644
--- a/integration-tests/test-helper.js
+++ b/integration-tests/test-helper.js
@@ -258,6 +258,11 @@ export class TestRig {
 
             result = filteredLines.join('\n');
           }
+          // If we have stderr output, include that also
+          if (stderr) {
+            result += `\n\nStdErr:\n${stderr}`;
+          }
+
           resolve(result);
         } else {
           reject(new Error(`Process exited with code ${code}:\n${stderr}`));
diff --git a/packages/core/src/core/geminiChat.ts b/packages/core/src/core/geminiChat.ts
index c0e41b5e..5f5b22e8 100644
--- a/packages/core/src/core/geminiChat.ts
+++ b/packages/core/src/core/geminiChat.ts
@@ -300,16 +300,14 @@ export class GeminiChat {
       };
 
       response = await retryWithBackoff(apiCall, {
-        shouldRetry: (error: Error) => {
-          // Check for likely cyclic schema errors, don't retry those.
-          if (error.message.includes('maximum schema depth exceeded'))
-            return false;
-          // Check error messages for status codes, or specific error names if known
-          if (error && error.message) {
+        shouldRetry: (error: unknown) => {
+          // Check for known error messages and codes.
+          if (error instanceof Error && error.message) {
+            if (isSchemaDepthError(error.message)) return false;
             if (error.message.includes('429')) return true;
             if (error.message.match(/5\d{2}/)) return true;
           }
-          return false;
+          return false; // Don't retry other errors by default
         },
         onPersistent429: async (authType?: string, error?: unknown) =>
           await this.handleFlashFallback(authType, error),
@@ -419,12 +417,10 @@ export class GeminiChat {
       // the stream. For simple 429/500 errors on initial call, this is fine.
       // If errors occur mid-stream, this setup won't resume the stream; it will restart it.
       const streamResponse = await retryWithBackoff(apiCall, {
-        shouldRetry: (error: Error) => {
-          // Check for likely cyclic schema errors, don't retry those.
-          if (error.message.includes('maximum schema depth exceeded'))
-            return false;
-          // Check error messages for status codes, or specific error names if known
-          if (error && error.message) {
+        shouldRetry: (error: unknown) => {
+          // Check for known error messages and codes.
+          if (error instanceof Error && error.message) {
+            if (isSchemaDepthError(error.message)) return false;
             if (error.message.includes('429')) return true;
             if (error.message.match(/5\d{2}/)) return true;
           }
@@ -689,10 +685,7 @@ export class GeminiChat {
   private async maybeIncludeSchemaDepthContext(error: unknown): Promise<void> {
     // Check for potentially problematic cyclic tools with cyclic schemas
     // and include a recommendation to remove potentially problematic tools.
-    if (
-      isStructuredError(error) &&
-      error.message.includes('maximum schema depth exceeded')
-    ) {
+    if (isStructuredError(error) && isSchemaDepthError(error.message)) {
       const tools = (await this.config.getToolRegistry()).getAllTools();
       const cyclicSchemaTools: string[] = [];
       for (const tool of tools) {
@@ -714,3 +707,8 @@ export class GeminiChat {
     }
   }
 }
+
+/** Visible for Testing */
+export function isSchemaDepthError(errorMessage: string): boolean {
+  return errorMessage.includes('maximum schema depth exceeded');
+}

From ad5d2af4e34fd23391bb6a0270cc320a0e56ba88 Mon Sep 17 00:00:00 2001
From: Jack Wotherspoon <jackwoth@google.com>
Date: Wed, 6 Aug 2025 16:46:50 -0400
Subject: [PATCH 022/107] tests: fix e2e tests (#5706)

---
 integration-tests/test-helper.js | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/integration-tests/test-helper.js b/integration-tests/test-helper.js
index e4d55631..d1125a78 100644
--- a/integration-tests/test-helper.js
+++ b/integration-tests/test-helper.js
@@ -169,13 +169,13 @@ export class TestRig {
     };
 
     if (typeof promptOrOptions === 'string') {
-      command += ` --prompt "${promptOrOptions}"`;
+      command += ` --prompt ${JSON.stringify(promptOrOptions)}`;
     } else if (
       typeof promptOrOptions === 'object' &&
       promptOrOptions !== null
     ) {
       if (promptOrOptions.prompt) {
-        command += ` --prompt "${promptOrOptions.prompt}"`;
+        command += ` --prompt ${JSON.stringify(promptOrOptions.prompt)}`;
       }
       if (promptOrOptions.stdin) {
         execOptions.input = promptOrOptions.stdin;

From 43510ed212ea29b7bd752277de525f7821551b22 Mon Sep 17 00:00:00 2001
From: joshualitt <joshualitt@google.com>
Date: Wed, 6 Aug 2025 13:52:04 -0700
Subject: [PATCH 023/107] bug(core): Prompt engineering for truncated
 read_file. (#5161)

---
 packages/core/src/tools/read-file.test.ts     | 27 +++++++++++-------
 packages/core/src/tools/read-file.ts          | 24 ++++++++++++++--
 .../core/src/tools/read-many-files.test.ts    | 28 +++++++++++++++++++
 packages/core/src/tools/read-many-files.ts    | 12 +++++---
 packages/core/src/utils/fileUtils.test.ts     | 11 +-------
 packages/core/src/utils/fileUtils.ts          | 11 ++------
 6 files changed, 77 insertions(+), 36 deletions(-)

diff --git a/packages/core/src/tools/read-file.test.ts b/packages/core/src/tools/read-file.test.ts
index bb9317fd..8c11afab 100644
--- a/packages/core/src/tools/read-file.test.ts
+++ b/packages/core/src/tools/read-file.test.ts
@@ -222,7 +222,7 @@ describe('ReadFileTool', () => {
         });
       });
 
-      it('should pass offset and limit to read a slice of a text file', async () => {
+      it('should return a structured message when a slice of a text file is read', async () => {
         const filePath = path.join(tempRootDir, 'paginated.txt');
         const fileContent = Array.from(
           { length: 20 },
@@ -240,15 +240,22 @@ describe('ReadFileTool', () => {
           ToolResult
         >;
 
-        expect(await invocation.execute(abortSignal)).toEqual({
-          llmContent: [
-            '[File content truncated: showing lines 6-8 of 20 total lines. Use offset/limit parameters to view more.]',
-            'Line 6',
-            'Line 7',
-            'Line 8',
-          ].join('\n'),
-          returnDisplay: 'Read lines 6-8 of 20 from paginated.txt',
-        });
+        const result = await invocation.execute(abortSignal);
+
+        const expectedLlmContent = `
+IMPORTANT: The file content has been truncated.
+Status: Showing lines 6-8 of 20 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: 8.
+
+--- FILE CONTENT (truncated) ---
+Line 6
+Line 7
+Line 8`;
+
+        expect(result.llmContent).toEqual(expectedLlmContent);
+        expect(result.returnDisplay).toBe(
+          'Read lines 6-8 of 20 from paginated.txt',
+        );
       });
 
       describe('with .geminiignore', () => {
diff --git a/packages/core/src/tools/read-file.ts b/packages/core/src/tools/read-file.ts
index 3a05da06..7ef9d2b5 100644
--- a/packages/core/src/tools/read-file.ts
+++ b/packages/core/src/tools/read-file.ts
@@ -14,7 +14,7 @@ import {
   ToolLocation,
   ToolResult,
 } from './tools.js';
-import { Type } from '@google/genai';
+import { PartUnion, Type } from '@google/genai';
 import {
   processSingleFileContent,
   getSpecificMimeType,
@@ -84,6 +84,24 @@ class ReadFileToolInvocation
       };
     }
 
+    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
@@ -98,7 +116,7 @@ class ReadFileToolInvocation
     );
 
     return {
-      llmContent: result.llmContent || '',
+      llmContent,
       returnDisplay: result.returnDisplay || '',
     };
   }
@@ -117,7 +135,7 @@ export class ReadFileTool extends BaseDeclarativeTool<
     super(
       ReadFileTool.Name,
       'ReadFile',
-      'Reads and returns the content of a specified file from the local filesystem. Handles text, images (PNG, JPG, GIF, WEBP, SVG, BMP), and PDF files. For text files, it can read specific line ranges.',
+      `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.`,
       Icon.FileSearch,
       {
         properties: {
diff --git a/packages/core/src/tools/read-many-files.test.ts b/packages/core/src/tools/read-many-files.test.ts
index 6ddd2a08..4035a6b7 100644
--- a/packages/core/src/tools/read-many-files.test.ts
+++ b/packages/core/src/tools/read-many-files.test.ts
@@ -476,6 +476,34 @@ describe('ReadManyFilesTool', () => {
       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 result = await tool.execute(params, 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');
+    });
   });
 
   describe('Batch Processing', () => {
diff --git a/packages/core/src/tools/read-many-files.ts b/packages/core/src/tools/read-many-files.ts
index 1fa2e15c..a380ea91 100644
--- a/packages/core/src/tools/read-many-files.ts
+++ b/packages/core/src/tools/read-many-files.ts
@@ -524,11 +524,15 @@ Use this tool when the user's query implies needing the content of several files
               '{filePath}',
               filePath,
             );
-            contentParts.push(
-              `${separator}\n\n${fileReadResult.llmContent}\n\n`,
-            );
+            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 {
-            contentParts.push(fileReadResult.llmContent); // This is a Part for image/pdf
+            // This is a Part for image/pdf, which we don't add the separator to.
+            contentParts.push(fileReadResult.llmContent);
           }
 
           processedFilesRelativePaths.push(relativePathForDisplay);
diff --git a/packages/core/src/utils/fileUtils.test.ts b/packages/core/src/utils/fileUtils.test.ts
index fb6b6820..cfedfe27 100644
--- a/packages/core/src/utils/fileUtils.test.ts
+++ b/packages/core/src/utils/fileUtils.test.ts
@@ -420,10 +420,7 @@ describe('fileUtils', () => {
       ); // Read lines 6-10
       const expectedContent = lines.slice(5, 10).join('\n');
 
-      expect(result.llmContent).toContain(expectedContent);
-      expect(result.llmContent).toContain(
-        '[File content truncated: showing lines 6-10 of 20 total lines. Use offset/limit parameters to view more.]',
-      );
+      expect(result.llmContent).toBe(expectedContent);
       expect(result.returnDisplay).toBe('Read lines 6-10 of 20 from test.txt');
       expect(result.isTruncated).toBe(true);
       expect(result.originalLineCount).toBe(20);
@@ -444,9 +441,6 @@ describe('fileUtils', () => {
       const expectedContent = lines.slice(10, 20).join('\n');
 
       expect(result.llmContent).toContain(expectedContent);
-      expect(result.llmContent).toContain(
-        '[File content truncated: showing lines 11-20 of 20 total lines. Use offset/limit parameters to view more.]',
-      );
       expect(result.returnDisplay).toBe('Read lines 11-20 of 20 from test.txt');
       expect(result.isTruncated).toBe(true); // This is the key check for the bug
       expect(result.originalLineCount).toBe(20);
@@ -489,9 +483,6 @@ describe('fileUtils', () => {
         longLine.substring(0, 2000) + '... [truncated]',
       );
       expect(result.llmContent).toContain('Another short line');
-      expect(result.llmContent).toContain(
-        '[File content partially truncated: some lines exceeded maximum length of 2000 characters.]',
-      );
       expect(result.returnDisplay).toBe(
         'Read all 3 lines from test.txt (some lines were shortened)',
       );
diff --git a/packages/core/src/utils/fileUtils.ts b/packages/core/src/utils/fileUtils.ts
index a153d205..30ab69c6 100644
--- a/packages/core/src/utils/fileUtils.ts
+++ b/packages/core/src/utils/fileUtils.ts
@@ -303,14 +303,7 @@ export async function processSingleFileContent(
         const contentRangeTruncated =
           startLine > 0 || endLine < originalLineCount;
         const isTruncated = contentRangeTruncated || linesWereTruncatedInLength;
-
-        let llmTextContent = '';
-        if (contentRangeTruncated) {
-          llmTextContent += `[File content truncated: showing lines ${actualStartLine + 1}-${endLine} of ${originalLineCount} total lines. Use offset/limit parameters to view more.]\n`;
-        } else if (linesWereTruncatedInLength) {
-          llmTextContent += `[File content partially truncated: some lines exceeded maximum length of ${MAX_LINE_LENGTH_TEXT_FILE} characters.]\n`;
-        }
-        llmTextContent += formattedLines.join('\n');
+        const llmContent = formattedLines.join('\n');
 
         // By default, return nothing to streamline the common case of a successful read_file.
         let returnDisplay = '';
@@ -326,7 +319,7 @@ export async function processSingleFileContent(
         }
 
         return {
-          llmContent: llmTextContent,
+          llmContent,
           returnDisplay,
           isTruncated,
           originalLineCount,

From b55467c1dd3515b35607a2abfbdefaa79bf6a48f Mon Sep 17 00:00:00 2001
From: christine betts <chrstn@uw.edu>
Date: Wed, 6 Aug 2025 20:55:29 +0000
Subject: [PATCH 024/107] [ide-mode] Support rendering in-IDE diffs using the
 edit tool (#5618)

Co-authored-by: gemini-code-assist[bot] <176961590+gemini-code-assist[bot]@users.noreply.github.com>
---
 .../messages/ToolConfirmationMessage.tsx      |  2 -
 packages/core/src/tools/edit.test.ts          | 60 ++++++++++++++++++-
 packages/core/src/tools/edit.ts               | 20 +++++++
 3 files changed, 79 insertions(+), 3 deletions(-)

diff --git a/packages/cli/src/ui/components/messages/ToolConfirmationMessage.tsx b/packages/cli/src/ui/components/messages/ToolConfirmationMessage.tsx
index 8b7f93d1..b4fe4167 100644
--- a/packages/cli/src/ui/components/messages/ToolConfirmationMessage.tsx
+++ b/packages/cli/src/ui/components/messages/ToolConfirmationMessage.tsx
@@ -138,8 +138,6 @@ export const ToolConfirmationMessage: React.FC<
         value: ToolConfirmationOutcome.Cancel,
       });
     } else {
-      // TODO(chrstnb): support edit tool in IDE mode.
-
       options.push({
         label: 'Modify with external editor',
         value: ToolConfirmationOutcome.ModifyWithEditor,
diff --git a/packages/core/src/tools/edit.test.ts b/packages/core/src/tools/edit.test.ts
index 029d3a3c..3bfa023e 100644
--- a/packages/core/src/tools/edit.test.ts
+++ b/packages/core/src/tools/edit.test.ts
@@ -10,6 +10,8 @@ const mockEnsureCorrectEdit = vi.hoisted(() => vi.fn());
 const mockGenerateJson = vi.hoisted(() => vi.fn());
 const mockOpenDiff = vi.hoisted(() => vi.fn());
 
+import { IDEConnectionStatus } from '../ide/ide-client.js';
+
 vi.mock('../utils/editCorrector.js', () => ({
   ensureCorrectEdit: mockEnsureCorrectEdit,
 }));
@@ -26,7 +28,7 @@ vi.mock('../utils/editor.js', () => ({
 
 import { describe, it, expect, beforeEach, afterEach, vi, Mock } from 'vitest';
 import { EditTool, EditToolParams } from './edit.js';
-import { FileDiff } from './tools.js';
+import { FileDiff, ToolConfirmationOutcome } from './tools.js';
 import { ToolErrorType } from './tool-error.js';
 import path from 'path';
 import fs from 'fs';
@@ -58,6 +60,9 @@ describe('EditTool', () => {
       getApprovalMode: vi.fn(),
       setApprovalMode: vi.fn(),
       getWorkspaceContext: () => createMockWorkspaceContext(rootDir),
+      getIdeClient: () => undefined,
+      getIdeMode: () => false,
+      getIdeModeFeature: () => false,
       // getGeminiConfig: () => ({ apiKey: 'test-api-key' }), // This was not a real Config method
       // Add other properties/methods of Config if EditTool uses them
       // Minimal other methods to satisfy Config type if needed by EditTool constructor or other direct uses:
@@ -796,4 +801,57 @@ describe('EditTool', () => {
       expect(error).toContain(rootDir);
     });
   });
+
+  describe('IDE mode', () => {
+    const testFile = 'edit_me.txt';
+    let filePath: string;
+    let ideClient: any;
+
+    beforeEach(() => {
+      filePath = path.join(rootDir, testFile);
+      ideClient = {
+        openDiff: vi.fn(),
+        getConnectionStatus: vi.fn().mockReturnValue({
+          status: IDEConnectionStatus.Connected,
+        }),
+      };
+      (mockConfig as any).getIdeMode = () => true;
+      (mockConfig as any).getIdeModeFeature = () => true;
+      (mockConfig as any).getIdeClient = () => ideClient;
+    });
+
+    it('should call ideClient.openDiff and update params on confirmation', async () => {
+      const initialContent = 'some old content here';
+      const newContent = 'some new content here';
+      const modifiedContent = 'some modified content here';
+      fs.writeFileSync(filePath, initialContent);
+      const params: EditToolParams = {
+        file_path: filePath,
+        old_string: 'old',
+        new_string: 'new',
+      };
+      mockEnsureCorrectEdit.mockResolvedValueOnce({
+        params: { ...params, old_string: 'old', new_string: 'new' },
+        occurrences: 1,
+      });
+      ideClient.openDiff.mockResolvedValueOnce({
+        status: 'accepted',
+        content: modifiedContent,
+      });
+
+      const confirmation = await tool.shouldConfirmExecute(
+        params,
+        new AbortController().signal,
+      );
+
+      expect(ideClient.openDiff).toHaveBeenCalledWith(filePath, newContent);
+
+      if (confirmation && 'onConfirm' in confirmation) {
+        await confirmation.onConfirm(ToolConfirmationOutcome.ProceedOnce);
+      }
+
+      expect(params.old_string).toBe(initialContent);
+      expect(params.new_string).toBe(modifiedContent);
+    });
+  });
 });
diff --git a/packages/core/src/tools/edit.ts b/packages/core/src/tools/edit.ts
index 853ad4c1..43505182 100644
--- a/packages/core/src/tools/edit.ts
+++ b/packages/core/src/tools/edit.ts
@@ -27,6 +27,7 @@ import { ensureCorrectEdit } from '../utils/editCorrector.js';
 import { DEFAULT_DIFF_OPTIONS } from './diffOptions.js';
 import { ReadFileTool } from './read-file.js';
 import { ModifiableDeclarativeTool, ModifyContext } from './modifiable-tool.js';
+import { IDEConnectionStatus } from '../ide/ide-client.js';
 
 /**
  * Parameters for the Edit tool
@@ -328,6 +329,14 @@ Expectation for required parameters:
       'Proposed',
       DEFAULT_DIFF_OPTIONS,
     );
+    const ideClient = this.config.getIdeClient();
+    const ideConfirmation =
+      this.config.getIdeModeFeature() &&
+      this.config.getIdeMode() &&
+      ideClient?.getConnectionStatus().status === IDEConnectionStatus.Connected
+        ? ideClient.openDiff(params.file_path, editData.newContent)
+        : undefined;
+
     const confirmationDetails: ToolEditConfirmationDetails = {
       type: 'edit',
       title: `Confirm Edit: ${shortenPath(makeRelative(params.file_path, this.config.getTargetDir()))}`,
@@ -340,7 +349,18 @@ Expectation for required parameters:
         if (outcome === ToolConfirmationOutcome.ProceedAlways) {
           this.config.setApprovalMode(ApprovalMode.AUTO_EDIT);
         }
+
+        if (ideConfirmation) {
+          const result = await ideConfirmation;
+          if (result.status === 'accepted' && result.content) {
+            // TODO(chrstn): See https://github.com/google-gemini/gemini-cli/pull/5618#discussion_r2255413084
+            // for info on a possible race condition where the file is modified on disk while being edited.
+            params.old_string = editData.currentContent ?? '';
+            params.new_string = result.content;
+          }
+        }
       },
+      ideConfirmation,
     };
     return confirmationDetails;
   }

From 5cd63a6abc0531ec5e6781b2fa065cd22a64eede Mon Sep 17 00:00:00 2001
From: Seth Vargo <seth@sethvargo.com>
Date: Wed, 6 Aug 2025 16:56:06 -0400
Subject: [PATCH 025/107] feat(cli): get the run-gemini-cli version from the
 GitHub API (#5708)

---
 .../ui/commands/setupGithubCommand.test.ts    |  59 ++++-----
 .../cli/src/ui/commands/setupGithubCommand.ts |  78 +++++++++---
 packages/cli/src/utils/gitUtils.test.ts       | 115 ++++++++++++++++++
 packages/cli/src/utils/gitUtils.ts            |  77 +++++++++++-
 4 files changed, 272 insertions(+), 57 deletions(-)
 create mode 100644 packages/cli/src/utils/gitUtils.test.ts

diff --git a/packages/cli/src/ui/commands/setupGithubCommand.test.ts b/packages/cli/src/ui/commands/setupGithubCommand.test.ts
index ae6378c7..6417c60a 100644
--- a/packages/cli/src/ui/commands/setupGithubCommand.test.ts
+++ b/packages/cli/src/ui/commands/setupGithubCommand.test.ts
@@ -5,13 +5,22 @@
  */
 
 import { vi, describe, expect, it, afterEach, beforeEach } from 'vitest';
-import * as child_process from 'child_process';
+import * as gitUtils from '../../utils/gitUtils.js';
 import { setupGithubCommand } from './setupGithubCommand.js';
 import { CommandContext, ToolActionReturn } from './types.js';
 
 vi.mock('child_process');
 
-describe('setupGithubCommand', () => {
+// Mock fetch globally
+global.fetch = vi.fn();
+
+vi.mock('../../utils/gitUtils.js', () => ({
+  isGitHubRepository: vi.fn(),
+  getGitRepoRoot: vi.fn(),
+  getLatestGitHubRelease: vi.fn(),
+}));
+
+describe('setupGithubCommand', async () => {
   beforeEach(() => {
     vi.resetAllMocks();
   });
@@ -20,49 +29,35 @@ describe('setupGithubCommand', () => {
     vi.restoreAllMocks();
   });
 
-  it('returns a tool action to download github workflows and handles paths', () => {
+  it('returns a tool action to download github workflows and handles paths', async () => {
     const fakeRepoRoot = '/github.com/fake/repo/root';
-    vi.mocked(child_process.execSync).mockReturnValue(fakeRepoRoot);
+    const fakeReleaseVersion = 'v1.2.3';
 
-    const result = setupGithubCommand.action?.(
+    vi.mocked(gitUtils.isGitHubRepository).mockReturnValueOnce(true);
+    vi.mocked(gitUtils.getGitRepoRoot).mockReturnValueOnce(fakeRepoRoot);
+    vi.mocked(gitUtils.getLatestGitHubRelease).mockResolvedValueOnce(
+      fakeReleaseVersion,
+    );
+
+    const result = (await setupGithubCommand.action?.(
       {} as CommandContext,
       '',
-    ) as ToolActionReturn;
-
-    expect(result.type).toBe('tool');
-    expect(result.toolName).toBe('run_shell_command');
-    expect(child_process.execSync).toHaveBeenCalledWith(
-      'git rev-parse --show-toplevel',
-      {
-        encoding: 'utf-8',
-      },
-    );
-    expect(child_process.execSync).toHaveBeenCalledWith('git remote -v', {
-      encoding: 'utf-8',
-    });
+    )) as ToolActionReturn;
 
     const { command } = result.toolArgs;
 
     const expectedSubstrings = [
+      `set -eEuo pipefail`,
       `mkdir -p "${fakeRepoRoot}/.github/workflows"`,
-      `curl -fsSL -o "${fakeRepoRoot}/.github/workflows/gemini-cli.yml"`,
-      `curl -fsSL -o "${fakeRepoRoot}/.github/workflows/gemini-issue-automated-triage.yml"`,
-      `curl -fsSL -o "${fakeRepoRoot}/.github/workflows/gemini-issue-scheduled-triage.yml"`,
-      `curl -fsSL -o "${fakeRepoRoot}/.github/workflows/gemini-pr-review.yml"`,
-      'https://raw.githubusercontent.com/google-github-actions/run-gemini-cli/refs/tags/v0/examples/workflows/',
+      `curl --fail --location --output "/github.com/fake/repo/root/.github/workflows/gemini-cli.yml" --show-error --silent`,
+      `curl --fail --location --output "/github.com/fake/repo/root/.github/workflows/gemini-issue-automated-triage.yml" --show-error --silent`,
+      `curl --fail --location --output "/github.com/fake/repo/root/.github/workflows/gemini-issue-scheduled-triage.yml" --show-error --silent`,
+      `curl --fail --location --output "/github.com/fake/repo/root/.github/workflows/gemini-pr-review.yml" --show-error --silent`,
+      `https://raw.githubusercontent.com/google-github-actions/run-gemini-cli/refs/tags/`,
     ];
 
     for (const substring of expectedSubstrings) {
       expect(command).toContain(substring);
     }
   });
-
-  it('throws an error if git root cannot be determined', () => {
-    vi.mocked(child_process.execSync).mockReturnValue('');
-    expect(() => {
-      setupGithubCommand.action?.({} as CommandContext, '');
-    }).toThrow(
-      'Unable to determine the GitHub repository. /setup-github must be run from a git repository.',
-    );
-  });
 });
diff --git a/packages/cli/src/ui/commands/setupGithubCommand.ts b/packages/cli/src/ui/commands/setupGithubCommand.ts
index 047e11eb..1b5b3277 100644
--- a/packages/cli/src/ui/commands/setupGithubCommand.ts
+++ b/packages/cli/src/ui/commands/setupGithubCommand.ts
@@ -5,8 +5,13 @@
  */
 
 import path from 'path';
-import { execSync } from 'child_process';
-import { isGitHubRepository } from '../../utils/gitUtils.js';
+
+import { CommandContext } from '../../ui/commands/types.js';
+import {
+  getGitRepoRoot,
+  getLatestGitHubRelease,
+  isGitHubRepository,
+} from '../../utils/gitUtils.js';
 
 import {
   CommandKind,
@@ -18,26 +23,29 @@ export const setupGithubCommand: SlashCommand = {
   name: 'setup-github',
   description: 'Set up GitHub Actions',
   kind: CommandKind.BUILT_IN,
-  action: (): SlashCommandActionReturn => {
+  action: async (
+    context: CommandContext,
+  ): Promise<SlashCommandActionReturn> => {
     if (!isGitHubRepository()) {
       throw new Error(
         'Unable to determine the GitHub repository. /setup-github must be run from a git repository.',
       );
     }
 
-    let gitRootRepo: string;
+    // Find the root directory of the repo
+    let gitRepoRoot: string;
     try {
-      gitRootRepo = execSync('git rev-parse --show-toplevel', {
-        encoding: 'utf-8',
-      }).trim();
-    } catch {
+      gitRepoRoot = getGitRepoRoot();
+    } catch (_error) {
+      console.debug(`Failed to get git repo root:`, _error);
       throw new Error(
         'Unable to determine the GitHub repository. /setup-github must be run from a git repository.',
       );
     }
 
-    const version = 'v0';
-    const workflowBaseUrl = `https://raw.githubusercontent.com/google-github-actions/run-gemini-cli/refs/tags/${version}/examples/workflows/`;
+    // Get the latest release tag from GitHub
+    const proxy = context?.services?.config?.getProxy();
+    const releaseTag = await getLatestGitHubRelease(proxy);
 
     const workflows = [
       'gemini-cli/gemini-cli.yml',
@@ -46,16 +54,29 @@ export const setupGithubCommand: SlashCommand = {
       'pr-review/gemini-pr-review.yml',
     ];
 
-    const command = [
-      'set -e',
-      `mkdir -p "${gitRootRepo}/.github/workflows"`,
-      ...workflows.map((workflow) => {
-        const fileName = path.basename(workflow);
-        return `curl -fsSL -o "${gitRootRepo}/.github/workflows/${fileName}" "${workflowBaseUrl}/${workflow}"`;
-      }),
-      'echo "Workflows downloaded successfully. Follow steps in https://github.com/google-github-actions/run-gemini-cli/blob/v0/README.md#quick-start (skipping the /setup-github step) to complete setup."',
-      'open https://github.com/google-github-actions/run-gemini-cli/blob/v0/README.md#quick-start',
-    ].join(' && ');
+    const commands = [];
+
+    // Ensure fast exit
+    commands.push(`set -eEuo pipefail`);
+
+    // Make the directory if it doesn't exist
+    commands.push(`mkdir -p "${gitRepoRoot}/.github/workflows"`);
+
+    for (const workflow of workflows) {
+      const fileName = path.basename(workflow);
+      const curlCommand = buildCurlCommand(
+        `https://raw.githubusercontent.com/google-github-actions/run-gemini-cli/refs/tags/${releaseTag}/examples/workflows/${workflow}`,
+        [`--output "${gitRepoRoot}/.github/workflows/${fileName}"`],
+      );
+      commands.push(curlCommand);
+    }
+
+    commands.push(
+      `echo "Successfully downloaded ${workflows.length} workflows. Follow the steps in https://github.com/google-github-actions/run-gemini-cli/blob/${releaseTag}/README.md#quick-start (skipping the /setup-github step) to complete setup."`,
+      `open https://github.com/google-github-actions/run-gemini-cli/blob/${releaseTag}/README.md#quick-start`,
+    );
+
+    const command = `(${commands.join(' && ')})`;
     return {
       type: 'tool',
       toolName: 'run_shell_command',
@@ -67,3 +88,20 @@ export const setupGithubCommand: SlashCommand = {
     };
   },
 };
+
+// buildCurlCommand is a helper for constructing a consistent curl command.
+function buildCurlCommand(u: string, additionalArgs?: string[]): string {
+  const args = [];
+  args.push('--fail');
+  args.push('--location');
+  args.push('--show-error');
+  args.push('--silent');
+
+  for (const val of additionalArgs || []) {
+    args.push(val);
+  }
+
+  args.sort();
+
+  return `curl ${args.join(' ')} "${u}"`;
+}
diff --git a/packages/cli/src/utils/gitUtils.test.ts b/packages/cli/src/utils/gitUtils.test.ts
new file mode 100644
index 00000000..4a29f589
--- /dev/null
+++ b/packages/cli/src/utils/gitUtils.test.ts
@@ -0,0 +1,115 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { vi, describe, expect, it, afterEach, beforeEach } from 'vitest';
+import * as child_process from 'child_process';
+import {
+  isGitHubRepository,
+  getGitRepoRoot,
+  getLatestGitHubRelease,
+} from './gitUtils.js';
+
+vi.mock('child_process');
+
+describe('isGitHubRepository', async () => {
+  beforeEach(() => {
+    vi.resetAllMocks();
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it('returns false if the git command fails', async () => {
+    vi.mocked(child_process.execSync).mockImplementation((): string => {
+      throw new Error('oops');
+    });
+    expect(isGitHubRepository()).toBe(false);
+  });
+
+  it('returns false if the remote is not github.com', async () => {
+    vi.mocked(child_process.execSync).mockReturnValueOnce('https://gitlab.com');
+    expect(isGitHubRepository()).toBe(false);
+  });
+
+  it('returns true if the remote is github.com', async () => {
+    vi.mocked(child_process.execSync).mockReturnValueOnce(`
+      origin  https://github.com/sethvargo/gemini-cli (fetch)
+      origin  https://github.com/sethvargo/gemini-cli (push)
+    `);
+    expect(isGitHubRepository()).toBe(true);
+  });
+});
+
+describe('getGitRepoRoot', async () => {
+  beforeEach(() => {
+    vi.resetAllMocks();
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it('throws an error if git root cannot be determined', async () => {
+    vi.mocked(child_process.execSync).mockImplementation((): string => {
+      throw new Error('oops');
+    });
+    expect(() => {
+      getGitRepoRoot();
+    }).toThrowError(/oops/);
+  });
+
+  it('throws an error if git root is empty', async () => {
+    vi.mocked(child_process.execSync).mockReturnValueOnce('');
+    expect(() => {
+      getGitRepoRoot();
+    }).toThrowError(/Git repo returned empty value/);
+  });
+
+  it('returns the root', async () => {
+    vi.mocked(child_process.execSync).mockReturnValueOnce('/path/to/git/repo');
+    expect(getGitRepoRoot()).toBe('/path/to/git/repo');
+  });
+});
+
+describe('getLatestRelease', async () => {
+  beforeEach(() => {
+    vi.resetAllMocks();
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it('throws an error if the fetch fails', async () => {
+    global.fetch = vi.fn(() => Promise.reject('nope'));
+    expect(getLatestGitHubRelease()).rejects.toThrowError(
+      /Unable to determine the latest/,
+    );
+  });
+
+  it('throws an error if the fetch does not return a json body', async () => {
+    global.fetch = vi.fn(() =>
+      Promise.resolve({
+        ok: true,
+        json: () => Promise.resolve({ foo: 'bar' }),
+      } as Response),
+    );
+    expect(getLatestGitHubRelease()).rejects.toThrowError(
+      /Unable to determine the latest/,
+    );
+  });
+
+  it('returns the release version', async () => {
+    global.fetch = vi.fn(() =>
+      Promise.resolve({
+        ok: true,
+        json: () => Promise.resolve({ tag_name: 'v1.2.3' }),
+      } as Response),
+    );
+    expect(getLatestGitHubRelease()).resolves.toBe('v1.2.3');
+  });
+});
diff --git a/packages/cli/src/utils/gitUtils.ts b/packages/cli/src/utils/gitUtils.ts
index d510008c..30ca2245 100644
--- a/packages/cli/src/utils/gitUtils.ts
+++ b/packages/cli/src/utils/gitUtils.ts
@@ -5,22 +5,89 @@
  */
 
 import { execSync } from 'child_process';
+import { ProxyAgent, setGlobalDispatcher } from 'undici';
 
 /**
  * Checks if a directory is within a git repository hosted on GitHub.
  * @returns true if the directory is in a git repository with a github.com remote, false otherwise
  */
-export function isGitHubRepository(): boolean {
+export const isGitHubRepository = (): boolean => {
   try {
-    const remotes = execSync('git remote -v', {
-      encoding: 'utf-8',
-    });
+    const remotes = (
+      execSync('git remote -v', {
+        encoding: 'utf-8',
+      }) || ''
+    ).trim();
 
     const pattern = /github\.com/;
 
     return pattern.test(remotes);
   } catch (_error) {
     // If any filesystem error occurs, assume not a git repo
+    console.debug(`Failed to get git remote:`, _error);
     return false;
   }
-}
+};
+
+/**
+ * getGitRepoRoot returns the root directory of the git repository.
+ * @returns the path to the root of the git repo.
+ * @throws error if the exec command fails.
+ */
+export const getGitRepoRoot = (): string => {
+  const gitRepoRoot = (
+    execSync('git rev-parse --show-toplevel', {
+      encoding: 'utf-8',
+    }) || ''
+  ).trim();
+
+  if (!gitRepoRoot) {
+    throw new Error(`Git repo returned empty value`);
+  }
+
+  return gitRepoRoot;
+};
+
+/**
+ * getLatestGitHubRelease returns the release tag as a string.
+ * @returns string of the release tag (e.g. "v1.2.3").
+ */
+export const getLatestGitHubRelease = async (
+  proxy?: string,
+): Promise<string> => {
+  try {
+    const controller = new AbortController();
+    if (proxy) {
+      setGlobalDispatcher(new ProxyAgent(proxy));
+    }
+
+    const endpoint = `https://api.github.com/repos/google-github-actions/run-gemini-cli/releases/latest`;
+
+    const response = await fetch(endpoint, {
+      method: 'GET',
+      headers: {
+        Accept: 'application/vnd.github+json',
+        'Content-Type': 'application/json',
+        'X-GitHub-Api-Version': '2022-11-28',
+      },
+      signal: controller.signal,
+    });
+
+    if (!response.ok) {
+      throw new Error(
+        `Invalid response code: ${response.status} - ${response.statusText}`,
+      );
+    }
+
+    const releaseTag = (await response.json()).tag_name;
+    if (!releaseTag) {
+      throw new Error(`Response did not include tag_name field`);
+    }
+    return releaseTag;
+  } catch (_error) {
+    console.debug(`Failed to determine latest run-gemini-cli release:`, _error);
+    throw new Error(
+      `Unable to determine the latest run-gemini-cli release on GitHub.`,
+    );
+  }
+};

From 626844b539af6bf6d21a04d43173074c98b71474 Mon Sep 17 00:00:00 2001
From: shrutip90 <shruti.p90@gmail.com>
Date: Wed, 6 Aug 2025 15:27:21 -0700
Subject: [PATCH 026/107] experiment: Add feature exp flag for folder trust
 (#5709)

---
 packages/cli/src/config/config.test.ts | 33 ++++++++++++++++++++++++++
 packages/cli/src/config/config.ts      |  3 +++
 packages/cli/src/config/settings.ts    |  1 +
 packages/core/src/config/config.ts     |  7 ++++++
 4 files changed, 44 insertions(+)

diff --git a/packages/cli/src/config/config.test.ts b/packages/cli/src/config/config.test.ts
index 64ecdbb8..6a7e3b57 100644
--- a/packages/cli/src/config/config.test.ts
+++ b/packages/cli/src/config/config.test.ts
@@ -1009,6 +1009,39 @@ describe('loadCliConfig ideModeFeature', () => {
   });
 });
 
+describe('loadCliConfig folderTrustFeature', () => {
+  const originalArgv = process.argv;
+  const originalEnv = { ...process.env };
+
+  beforeEach(() => {
+    vi.resetAllMocks();
+    vi.mocked(os.homedir).mockReturnValue('/mock/home/user');
+    process.env.GEMINI_API_KEY = 'test-api-key';
+  });
+
+  afterEach(() => {
+    process.argv = originalArgv;
+    process.env = originalEnv;
+    vi.restoreAllMocks();
+  });
+
+  it('should be false by default', async () => {
+    process.argv = ['node', 'script.js'];
+    const settings: Settings = {};
+    const argv = await parseArguments();
+    const config = await loadCliConfig(settings, [], 'test-session', argv);
+    expect(config.getFolderTrustFeature()).toBe(false);
+  });
+
+  it('should be true when settings.folderTrustFeature is true', async () => {
+    process.argv = ['node', 'script.js'];
+    const argv = await parseArguments();
+    const settings: Settings = { folderTrustFeature: true };
+    const config = await loadCliConfig(settings, [], 'test-session', argv);
+    expect(config.getFolderTrustFeature()).toBe(true);
+  });
+});
+
 vi.mock('fs', async () => {
   const actualFs = await vi.importActual<typeof fs>('fs');
   const MOCK_CWD1 = process.cwd();
diff --git a/packages/cli/src/config/config.ts b/packages/cli/src/config/config.ts
index 7175c033..2c942c08 100644
--- a/packages/cli/src/config/config.ts
+++ b/packages/cli/src/config/config.ts
@@ -313,6 +313,8 @@ export async function loadCliConfig(
   const ideModeFeature =
     argv.ideModeFeature ?? settings.ideModeFeature ?? false;
 
+  const folderTrustFeature = settings.folderTrustFeature ?? false;
+
   const allExtensions = annotateActiveExtensions(
     extensions,
     argv.extensions || [],
@@ -480,6 +482,7 @@ export async function loadCliConfig(
     summarizeToolOutput: settings.summarizeToolOutput,
     ideMode,
     ideModeFeature,
+    folderTrustFeature,
   });
 }
 
diff --git a/packages/cli/src/config/settings.ts b/packages/cli/src/config/settings.ts
index 93641ae0..64500845 100644
--- a/packages/cli/src/config/settings.ts
+++ b/packages/cli/src/config/settings.ts
@@ -112,6 +112,7 @@ export interface Settings {
 
   // Flag to be removed post-launch.
   ideModeFeature?: boolean;
+  folderTrustFeature?: boolean;
   /// IDE mode setting configured via slash command toggle.
   ideMode?: boolean;
 
diff --git a/packages/core/src/config/config.ts b/packages/core/src/config/config.ts
index fa51a6af..005573da 100644
--- a/packages/core/src/config/config.ts
+++ b/packages/core/src/config/config.ts
@@ -188,6 +188,7 @@ export interface ConfigParameters {
   noBrowser?: boolean;
   summarizeToolOutput?: Record<string, SummarizeToolOutputSettings>;
   ideModeFeature?: boolean;
+  folderTrustFeature?: boolean;
   ideMode?: boolean;
   loadMemoryFromIncludeDirectories?: boolean;
 }
@@ -233,6 +234,7 @@ export class Config {
   private readonly extensionContextFilePaths: string[];
   private readonly noBrowser: boolean;
   private readonly ideModeFeature: boolean;
+  private readonly folderTrustFeature: boolean;
   private ideMode: boolean;
   private ideClient: IdeClient;
   private inFallbackMode = false;
@@ -305,6 +307,7 @@ export class Config {
     this.noBrowser = params.noBrowser ?? false;
     this.summarizeToolOutput = params.summarizeToolOutput;
     this.ideModeFeature = params.ideModeFeature ?? false;
+    this.folderTrustFeature = params.folderTrustFeature ?? false;
     this.ideMode = params.ideMode ?? false;
     this.ideClient = IdeClient.getInstance();
     if (this.ideMode && this.ideModeFeature) {
@@ -638,6 +641,10 @@ export class Config {
     return this.ideModeFeature;
   }
 
+  getFolderTrustFeature(): boolean {
+    return this.folderTrustFeature;
+  }
+
   getIdeMode(): boolean {
     return this.ideMode;
   }

From 4782113cebc990b54353e095db1eb6c5e654bdef Mon Sep 17 00:00:00 2001
From: Richie Foreman <richie.foreman@gmail.com>
Date: Wed, 6 Aug 2025 19:31:42 -0400
Subject: [PATCH 027/107] =?UTF-8?q?fix(core):=20Improve=20errors=20in=20si?=
 =?UTF-8?q?tuations=20where=20the=20command=20spawn=20does=20=E2=80=A6=20(?=
 =?UTF-8?q?#5723)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../services/shellExecutionService.test.ts    | 10 +++++
 .../src/services/shellExecutionService.ts     | 45 ++++++++++++++-----
 2 files changed, 43 insertions(+), 12 deletions(-)

diff --git a/packages/core/src/services/shellExecutionService.test.ts b/packages/core/src/services/shellExecutionService.test.ts
index cfce08d2..2fe51a5e 100644
--- a/packages/core/src/services/shellExecutionService.test.ts
+++ b/packages/core/src/services/shellExecutionService.test.ts
@@ -185,6 +185,16 @@ describe('ShellExecutionService', () => {
       expect(result.error).toBe(spawnError);
       expect(result.exitCode).toBe(1);
     });
+
+    it('handles errors that do not fire the exit event', async () => {
+      const error = new Error('spawn abc ENOENT');
+      const { result } = await simulateExecution('touch cat.jpg', (cp) => {
+        cp.emit('error', error); // No exit event is fired.
+      });
+
+      expect(result.error).toBe(error);
+      expect(result.exitCode).toBe(1);
+    });
   });
 
   describe('Aborting Commands', () => {
diff --git a/packages/core/src/services/shellExecutionService.ts b/packages/core/src/services/shellExecutionService.ts
index d1126a7d..3749fcf6 100644
--- a/packages/core/src/services/shellExecutionService.ts
+++ b/packages/core/src/services/shellExecutionService.ts
@@ -174,7 +174,19 @@ export class ShellExecutionService {
       child.stdout.on('data', (data) => handleOutput(data, 'stdout'));
       child.stderr.on('data', (data) => handleOutput(data, 'stderr'));
       child.on('error', (err) => {
+        const { stdout, stderr, finalBuffer } = cleanup();
         error = err;
+        resolve({
+          error,
+          stdout,
+          stderr,
+          rawOutput: finalBuffer,
+          output: stdout + (stderr ? `\n${stderr}` : ''),
+          exitCode: 1,
+          signal: null,
+          aborted: false,
+          pid: child.pid,
+        });
       });
 
       const abortHandler = async () => {
@@ -200,18 +212,8 @@ export class ShellExecutionService {
 
       abortSignal.addEventListener('abort', abortHandler, { once: true });
 
-      child.on('exit', (code, signal) => {
-        exited = true;
-        abortSignal.removeEventListener('abort', abortHandler);
-
-        if (stdoutDecoder) {
-          stdout += stripAnsi(stdoutDecoder.decode());
-        }
-        if (stderrDecoder) {
-          stderr += stripAnsi(stderrDecoder.decode());
-        }
-
-        const finalBuffer = Buffer.concat(outputChunks);
+      child.on('exit', (code: number, signal: NodeJS.Signals) => {
+        const { stdout, stderr, finalBuffer } = cleanup();
 
         resolve({
           rawOutput: finalBuffer,
@@ -225,6 +227,25 @@ export class ShellExecutionService {
           pid: child.pid,
         });
       });
+
+      /**
+       * Cleans up a process (and it's accompanying state) that is exiting or
+       * erroring and returns output formatted output buffers and strings
+       */
+      function cleanup() {
+        exited = true;
+        abortSignal.removeEventListener('abort', abortHandler);
+        if (stdoutDecoder) {
+          stdout += stripAnsi(stdoutDecoder.decode());
+        }
+        if (stderrDecoder) {
+          stderr += stripAnsi(stderrDecoder.decode());
+        }
+
+        const finalBuffer = Buffer.concat(outputChunks);
+
+        return { stdout, stderr, finalBuffer };
+      }
     });
 
     return { pid: child.pid, result };

From 9ac3e8b79ecc584805c27d3602612c30f2adee80 Mon Sep 17 00:00:00 2001
From: DevMassive <76215222+DevMassive@users.noreply.github.com>
Date: Thu, 7 Aug 2025 08:41:04 +0900
Subject: [PATCH 028/107] feat: Improve @-command file path completion with fzf
 integration (#5650)

Co-authored-by: Jacob Richman <jacob314@gmail.com>
---
 package-lock.json                             |  7 ++++++
 .../cli/src/ui/hooks/useAtCompletion.test.ts  |  2 +-
 packages/core/package.json                    |  1 +
 .../src/utils/filesearch/fileSearch.test.ts   | 24 +++++++++++++++++++
 .../core/src/utils/filesearch/fileSearch.ts   | 17 ++++++++++++-
 5 files changed, 49 insertions(+), 2 deletions(-)

diff --git a/package-lock.json b/package-lock.json
index b16c4904..1e5e4211 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -5540,6 +5540,12 @@
         "url": "https://github.com/sponsors/ljharb"
       }
     },
+    "node_modules/fzf": {
+      "version": "0.5.2",
+      "resolved": "https://registry.npmjs.org/fzf/-/fzf-0.5.2.tgz",
+      "integrity": "sha512-Tt4kuxLXFKHy8KT40zwsUPUkg1CrsgY25FxA2U/j/0WgEDCk3ddc/zLTCCcbSHX9FcKtLuVaDGtGE/STWC+j3Q==",
+      "license": "BSD-3-Clause"
+    },
     "node_modules/gcp-metadata": {
       "version": "6.1.1",
       "resolved": "https://registry.npmjs.org/gcp-metadata/-/gcp-metadata-6.1.1.tgz",
@@ -11889,6 +11895,7 @@
         "diff": "^7.0.0",
         "dotenv": "^17.1.0",
         "fdir": "^6.4.6",
+        "fzf": "^0.5.2",
         "glob": "^10.4.5",
         "google-auth-library": "^9.11.0",
         "html-to-text": "^9.0.5",
diff --git a/packages/cli/src/ui/hooks/useAtCompletion.test.ts b/packages/cli/src/ui/hooks/useAtCompletion.test.ts
index 43289992..aa198fc1 100644
--- a/packages/cli/src/ui/hooks/useAtCompletion.test.ts
+++ b/packages/cli/src/ui/hooks/useAtCompletion.test.ts
@@ -114,8 +114,8 @@ describe('useAtCompletion', () => {
       expect(result.current.suggestions.map((s) => s.value)).toEqual([
         'src/',
         'src/components/',
-        'src/components/Button.tsx',
         'src/index.js',
+        'src/components/Button.tsx',
       ]);
     });
 
diff --git a/packages/core/package.json b/packages/core/package.json
index 6e42a4a9..37e3687d 100644
--- a/packages/core/package.json
+++ b/packages/core/package.json
@@ -35,6 +35,7 @@
     "diff": "^7.0.0",
     "dotenv": "^17.1.0",
     "fdir": "^6.4.6",
+    "fzf": "^0.5.2",
     "glob": "^10.4.5",
     "google-auth-library": "^9.11.0",
     "html-to-text": "^9.0.5",
diff --git a/packages/core/src/utils/filesearch/fileSearch.test.ts b/packages/core/src/utils/filesearch/fileSearch.test.ts
index a7f59f91..38657492 100644
--- a/packages/core/src/utils/filesearch/fileSearch.test.ts
+++ b/packages/core/src/utils/filesearch/fileSearch.test.ts
@@ -290,6 +290,30 @@ describe('FileSearch', () => {
     expect(results).toEqual(['src/file1.js', 'src/file2.js']); // Assuming alphabetical sort
   });
 
+  it('should use fzf for fuzzy matching when pattern does not contain wildcards', async () => {
+    tmpDir = await createTmpDir({
+      src: {
+        'main.js': '',
+        'util.ts': '',
+        'style.css': '',
+      },
+    });
+
+    const fileSearch = new FileSearch({
+      projectRoot: tmpDir,
+      useGitignore: false,
+      useGeminiignore: false,
+      ignoreDirs: [],
+      cache: false,
+      cacheTtl: 0,
+    });
+
+    await fileSearch.initialize();
+    const results = await fileSearch.search('sst');
+
+    expect(results).toEqual(['src/style.css']);
+  });
+
   it('should return empty array when no matches are found', async () => {
     tmpDir = await createTmpDir({
       src: ['file1.js'],
diff --git a/packages/core/src/utils/filesearch/fileSearch.ts b/packages/core/src/utils/filesearch/fileSearch.ts
index db14bc65..76a099f7 100644
--- a/packages/core/src/utils/filesearch/fileSearch.ts
+++ b/packages/core/src/utils/filesearch/fileSearch.ts
@@ -11,6 +11,7 @@ import picomatch from 'picomatch';
 import { Ignore } from './ignore.js';
 import { ResultCache } from './result-cache.js';
 import * as cache from './crawlCache.js';
+import { Fzf, FzfResultItem } from 'fzf';
 
 export type FileSearchOptions = {
   projectRoot: string;
@@ -77,6 +78,18 @@ export async function filter(
   return results;
 }
 
+/**
+ * Filters a list of paths based on a given pattern using fzf.
+ * @param allPaths The list of all paths to filter.
+ * @param pattern The fzf pattern to filter by.
+ * @returns The filtered and sorted list of paths.
+ */
+function filterByFzf(allPaths: string[], pattern: string) {
+  return new Fzf(allPaths)
+    .find(pattern)
+    .map((entry: FzfResultItem) => entry.item);
+}
+
 export type SearchOptions = {
   signal?: AbortSignal;
   maxResults?: number;
@@ -137,7 +150,9 @@ export class FileSearch {
       filteredCandidates = candidates;
     } else {
       // Apply the user's picomatch pattern filter
-      filteredCandidates = await filter(candidates, pattern, options.signal);
+      filteredCandidates = pattern.includes('*')
+        ? await filter(candidates, pattern, options.signal)
+        : filterByFzf(this.allFiles, pattern);
       this.resultCache!.set(pattern, filteredCandidates);
     }
 

From 01f7c4b7406cd9ce94667dcbd5e586dad9573d67 Mon Sep 17 00:00:00 2001
From: "N. Taylor Mullen" <ntaylormullen@google.com>
Date: Wed, 6 Aug 2025 16:59:50 -0700
Subject: [PATCH 029/107] Fix(tests): update mcp_server_cyclic_schema test
 (#5733)

---
 integration-tests/mcp_server_cyclic_schema.test.js | 13 +++----------
 1 file changed, 3 insertions(+), 10 deletions(-)

diff --git a/integration-tests/mcp_server_cyclic_schema.test.js b/integration-tests/mcp_server_cyclic_schema.test.js
index a78e0922..1ace98f1 100644
--- a/integration-tests/mcp_server_cyclic_schema.test.js
+++ b/integration-tests/mcp_server_cyclic_schema.test.js
@@ -14,7 +14,7 @@ import { strict as assert } from 'node:assert';
 import { TestRig } from './test-helper.js';
 import { join } from 'path';
 import { fileURLToPath } from 'url';
-import { writeFileSync, readFileSync } from 'fs';
+import { writeFileSync } from 'fs';
 
 const __dirname = fileURLToPath(new URL('.', import.meta.url));
 
@@ -191,16 +191,9 @@ describe('mcp server with cyclic tool schema is detected', () => {
     // Or, possibly it could mean that gemini has fixed the issue.
     const output = await rig.run('hello');
 
-    // The error message is in a log file, so we need to extract the path and read it.
-    const match = output.match(/Full report available at: (.*\.json)/);
-    assert(match, `Could not find log file path in output: ${output}`);
-
-    const logFilePath = match[1];
-    const logFileContent = readFileSync(logFilePath, 'utf-8');
-
     assert.match(
-      logFileContent,
-      / - tool_with_cyclic_schema \(cyclic-schema-server MCP Server\)/,
+      output,
+      /Skipping tool 'tool_with_cyclic_schema' from MCP server 'cyclic-schema-server' because it has missing types in its parameter schema/,
     );
   });
 });

From 99f88851fb86b3bdb8408891391f8b733d7e0053 Mon Sep 17 00:00:00 2001
From: anthony bushong <agmsb@users.noreply.github.com>
Date: Wed, 6 Aug 2025 17:01:22 -0700
Subject: [PATCH 030/107] fix(actions): swap gha bot for cla allowlisted
 gemini-cli-robot (#5730)

---
 .github/workflows/release.yml | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index 9c449702..a011f776 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -99,8 +99,8 @@ jobs:
 
       - name: Configure Git User
         run: |
-          git config user.name "github-actions[bot]"
-          git config user.email "github-actions[bot]@users.noreply.github.com"
+          git config user.name "gemini-cli-robot"
+          git config user.email "gemini-cli-robot@google.com"
 
       - name: Create and switch to a release branch
         id: release_branch

From d6a7334279366762787bed6a5bd08a125c7c3ba8 Mon Sep 17 00:00:00 2001
From: Allen Hutchison <adh@google.com>
Date: Wed, 6 Aug 2025 17:19:10 -0700
Subject: [PATCH 031/107] fix(logging): Ensure sandbox startup messages are
 routed to stderr (#5725)

---
 packages/cli/src/ui/types.ts                |    2 +-
 packages/cli/src/ui/utils/ConsolePatcher.ts |    5 +-
 packages/cli/src/utils/sandbox.ts           | 1078 ++++++++++---------
 3 files changed, 551 insertions(+), 534 deletions(-)

diff --git a/packages/cli/src/ui/types.ts b/packages/cli/src/ui/types.ts
index 6d078b22..b52bf64d 100644
--- a/packages/cli/src/ui/types.ts
+++ b/packages/cli/src/ui/types.ts
@@ -224,7 +224,7 @@ export type Message =
     };
 
 export interface ConsoleMessageItem {
-  type: 'log' | 'warn' | 'error' | 'debug';
+  type: 'log' | 'warn' | 'error' | 'debug' | 'info';
   content: string;
   count: number;
 }
diff --git a/packages/cli/src/ui/utils/ConsolePatcher.ts b/packages/cli/src/ui/utils/ConsolePatcher.ts
index a429698d..8e95adc1 100644
--- a/packages/cli/src/ui/utils/ConsolePatcher.ts
+++ b/packages/cli/src/ui/utils/ConsolePatcher.ts
@@ -18,6 +18,7 @@ export class ConsolePatcher {
   private originalConsoleWarn = console.warn;
   private originalConsoleError = console.error;
   private originalConsoleDebug = console.debug;
+  private originalConsoleInfo = console.info;
 
   private params: ConsolePatcherParams;
 
@@ -30,6 +31,7 @@ export class ConsolePatcher {
     console.warn = this.patchConsoleMethod('warn', this.originalConsoleWarn);
     console.error = this.patchConsoleMethod('error', this.originalConsoleError);
     console.debug = this.patchConsoleMethod('debug', this.originalConsoleDebug);
+    console.info = this.patchConsoleMethod('info', this.originalConsoleInfo);
   }
 
   cleanup = () => {
@@ -37,13 +39,14 @@ export class ConsolePatcher {
     console.warn = this.originalConsoleWarn;
     console.error = this.originalConsoleError;
     console.debug = this.originalConsoleDebug;
+    console.info = this.originalConsoleInfo;
   };
 
   private formatArgs = (args: unknown[]): string => util.format(...args);
 
   private patchConsoleMethod =
     (
-      type: 'log' | 'warn' | 'error' | 'debug',
+      type: 'log' | 'warn' | 'error' | 'debug' | 'info',
       originalMethod: (...args: unknown[]) => void,
     ) =>
     (...args: unknown[]) => {
diff --git a/packages/cli/src/utils/sandbox.ts b/packages/cli/src/utils/sandbox.ts
index d53608d1..3550f45b 100644
--- a/packages/cli/src/utils/sandbox.ts
+++ b/packages/cli/src/utils/sandbox.ts
@@ -16,6 +16,7 @@ import {
 } from '../config/settings.js';
 import { promisify } from 'util';
 import { Config, SandboxConfig } from '@google/gemini-cli-core';
+import { ConsolePatcher } from '../ui/utils/ConsolePatcher.js';
 
 const execAsync = promisify(exec);
 
@@ -185,119 +186,564 @@ export async function start_sandbox(
   nodeArgs: string[] = [],
   cliConfig?: Config,
 ) {
-  if (config.command === 'sandbox-exec') {
-    // disallow BUILD_SANDBOX
+  const patcher = new ConsolePatcher({
+    debugMode: cliConfig?.getDebugMode() || !!process.env.DEBUG,
+    stderr: true,
+  });
+  patcher.patch();
+
+  try {
+    if (config.command === 'sandbox-exec') {
+      // disallow BUILD_SANDBOX
+      if (process.env.BUILD_SANDBOX) {
+        console.error('ERROR: cannot BUILD_SANDBOX when using macOS Seatbelt');
+        process.exit(1);
+      }
+      const profile = (process.env.SEATBELT_PROFILE ??= 'permissive-open');
+      let profileFile = new URL(`sandbox-macos-${profile}.sb`, import.meta.url)
+        .pathname;
+      // if profile name is not recognized, then look for file under project settings directory
+      if (!BUILTIN_SEATBELT_PROFILES.includes(profile)) {
+        profileFile = path.join(
+          SETTINGS_DIRECTORY_NAME,
+          `sandbox-macos-${profile}.sb`,
+        );
+      }
+      if (!fs.existsSync(profileFile)) {
+        console.error(
+          `ERROR: missing macos seatbelt profile file '${profileFile}'`,
+        );
+        process.exit(1);
+      }
+      // Log on STDERR so it doesn't clutter the output on STDOUT
+      console.error(`using macos seatbelt (profile: ${profile}) ...`);
+      // if DEBUG is set, convert to --inspect-brk in NODE_OPTIONS
+      const nodeOptions = [
+        ...(process.env.DEBUG ? ['--inspect-brk'] : []),
+        ...nodeArgs,
+      ].join(' ');
+
+      const args = [
+        '-D',
+        `TARGET_DIR=${fs.realpathSync(process.cwd())}`,
+        '-D',
+        `TMP_DIR=${fs.realpathSync(os.tmpdir())}`,
+        '-D',
+        `HOME_DIR=${fs.realpathSync(os.homedir())}`,
+        '-D',
+        `CACHE_DIR=${fs.realpathSync(execSync(`getconf DARWIN_USER_CACHE_DIR`).toString().trim())}`,
+      ];
+
+      // Add included directories from the workspace context
+      // Always add 5 INCLUDE_DIR parameters to ensure .sb files can reference them
+      const MAX_INCLUDE_DIRS = 5;
+      const targetDir = fs.realpathSync(cliConfig?.getTargetDir() || '');
+      const includedDirs: string[] = [];
+
+      if (cliConfig) {
+        const workspaceContext = cliConfig.getWorkspaceContext();
+        const directories = workspaceContext.getDirectories();
+
+        // Filter out TARGET_DIR
+        for (const dir of directories) {
+          const realDir = fs.realpathSync(dir);
+          if (realDir !== targetDir) {
+            includedDirs.push(realDir);
+          }
+        }
+      }
+
+      for (let i = 0; i < MAX_INCLUDE_DIRS; i++) {
+        let dirPath = '/dev/null'; // Default to a safe path that won't cause issues
+
+        if (i < includedDirs.length) {
+          dirPath = includedDirs[i];
+        }
+
+        args.push('-D', `INCLUDE_DIR_${i}=${dirPath}`);
+      }
+
+      args.push(
+        '-f',
+        profileFile,
+        'sh',
+        '-c',
+        [
+          `SANDBOX=sandbox-exec`,
+          `NODE_OPTIONS="${nodeOptions}"`,
+          ...process.argv.map((arg) => quote([arg])),
+        ].join(' '),
+      );
+      // start and set up proxy if GEMINI_SANDBOX_PROXY_COMMAND is set
+      const proxyCommand = process.env.GEMINI_SANDBOX_PROXY_COMMAND;
+      let proxyProcess: ChildProcess | undefined = undefined;
+      let sandboxProcess: ChildProcess | undefined = undefined;
+      const sandboxEnv = { ...process.env };
+      if (proxyCommand) {
+        const proxy =
+          process.env.HTTPS_PROXY ||
+          process.env.https_proxy ||
+          process.env.HTTP_PROXY ||
+          process.env.http_proxy ||
+          'http://localhost:8877';
+        sandboxEnv['HTTPS_PROXY'] = proxy;
+        sandboxEnv['https_proxy'] = proxy; // lower-case can be required, e.g. for curl
+        sandboxEnv['HTTP_PROXY'] = proxy;
+        sandboxEnv['http_proxy'] = proxy;
+        const noProxy = process.env.NO_PROXY || process.env.no_proxy;
+        if (noProxy) {
+          sandboxEnv['NO_PROXY'] = noProxy;
+          sandboxEnv['no_proxy'] = noProxy;
+        }
+        proxyProcess = spawn(proxyCommand, {
+          stdio: ['ignore', 'pipe', 'pipe'],
+          shell: true,
+          detached: true,
+        });
+        // install handlers to stop proxy on exit/signal
+        const stopProxy = () => {
+          console.log('stopping proxy ...');
+          if (proxyProcess?.pid) {
+            process.kill(-proxyProcess.pid, 'SIGTERM');
+          }
+        };
+        process.on('exit', stopProxy);
+        process.on('SIGINT', stopProxy);
+        process.on('SIGTERM', stopProxy);
+
+        // commented out as it disrupts ink rendering
+        // proxyProcess.stdout?.on('data', (data) => {
+        //   console.info(data.toString());
+        // });
+        proxyProcess.stderr?.on('data', (data) => {
+          console.error(data.toString());
+        });
+        proxyProcess.on('close', (code, signal) => {
+          console.error(
+            `ERROR: proxy command '${proxyCommand}' exited with code ${code}, signal ${signal}`,
+          );
+          if (sandboxProcess?.pid) {
+            process.kill(-sandboxProcess.pid, 'SIGTERM');
+          }
+          process.exit(1);
+        });
+        console.log('waiting for proxy to start ...');
+        await execAsync(
+          `until timeout 0.25 curl -s http://localhost:8877; do sleep 0.25; done`,
+        );
+      }
+      // spawn child and let it inherit stdio
+      sandboxProcess = spawn(config.command, args, {
+        stdio: 'inherit',
+      });
+      await new Promise((resolve) => sandboxProcess?.on('close', resolve));
+      return;
+    }
+
+    console.error(`hopping into sandbox (command: ${config.command}) ...`);
+
+    // determine full path for gemini-cli to distinguish linked vs installed setting
+    const gcPath = fs.realpathSync(process.argv[1]);
+
+    const projectSandboxDockerfile = path.join(
+      SETTINGS_DIRECTORY_NAME,
+      'sandbox.Dockerfile',
+    );
+    const isCustomProjectSandbox = fs.existsSync(projectSandboxDockerfile);
+
+    const image = config.image;
+    const workdir = path.resolve(process.cwd());
+    const containerWorkdir = getContainerPath(workdir);
+
+    // if BUILD_SANDBOX is set, then call scripts/build_sandbox.js under gemini-cli repo
+    //
+    // note this can only be done with binary linked from gemini-cli repo
     if (process.env.BUILD_SANDBOX) {
-      console.error('ERROR: cannot BUILD_SANDBOX when using macOS Seatbelt');
-      process.exit(1);
+      if (!gcPath.includes('gemini-cli/packages/')) {
+        console.error(
+          'ERROR: cannot build sandbox using installed gemini binary; ' +
+            'run `npm link ./packages/cli` under gemini-cli repo to switch to linked binary.',
+        );
+        process.exit(1);
+      } else {
+        console.error('building sandbox ...');
+        const gcRoot = gcPath.split('/packages/')[0];
+        // if project folder has sandbox.Dockerfile under project settings folder, use that
+        let buildArgs = '';
+        const projectSandboxDockerfile = path.join(
+          SETTINGS_DIRECTORY_NAME,
+          'sandbox.Dockerfile',
+        );
+        if (isCustomProjectSandbox) {
+          console.error(`using ${projectSandboxDockerfile} for sandbox`);
+          buildArgs += `-f ${path.resolve(projectSandboxDockerfile)} -i ${image}`;
+        }
+        execSync(
+          `cd ${gcRoot} && node scripts/build_sandbox.js -s ${buildArgs}`,
+          {
+            stdio: 'inherit',
+            env: {
+              ...process.env,
+              GEMINI_SANDBOX: config.command, // in case sandbox is enabled via flags (see config.ts under cli package)
+            },
+          },
+        );
+      }
     }
-    const profile = (process.env.SEATBELT_PROFILE ??= 'permissive-open');
-    let profileFile = new URL(`sandbox-macos-${profile}.sb`, import.meta.url)
-      .pathname;
-    // if profile name is not recognized, then look for file under project settings directory
-    if (!BUILTIN_SEATBELT_PROFILES.includes(profile)) {
-      profileFile = path.join(
-        SETTINGS_DIRECTORY_NAME,
-        `sandbox-macos-${profile}.sb`,
-      );
-    }
-    if (!fs.existsSync(profileFile)) {
+
+    // stop if image is missing
+    if (!(await ensureSandboxImageIsPresent(config.command, image))) {
+      const remedy =
+        image === LOCAL_DEV_SANDBOX_IMAGE_NAME
+          ? 'Try running `npm run build:all` or `npm run build:sandbox` under the gemini-cli repo to build it locally, or check the image name and your network connection.'
+          : 'Please check the image name, your network connection, or notify gemini-cli-dev@google.com if the issue persists.';
       console.error(
-        `ERROR: missing macos seatbelt profile file '${profileFile}'`,
+        `ERROR: Sandbox image '${image}' is missing or could not be pulled. ${remedy}`,
       );
       process.exit(1);
     }
-    // Log on STDERR so it doesn't clutter the output on STDOUT
-    console.error(`using macos seatbelt (profile: ${profile}) ...`);
-    // if DEBUG is set, convert to --inspect-brk in NODE_OPTIONS
-    const nodeOptions = [
-      ...(process.env.DEBUG ? ['--inspect-brk'] : []),
-      ...nodeArgs,
-    ].join(' ');
 
-    const args = [
-      '-D',
-      `TARGET_DIR=${fs.realpathSync(process.cwd())}`,
-      '-D',
-      `TMP_DIR=${fs.realpathSync(os.tmpdir())}`,
-      '-D',
-      `HOME_DIR=${fs.realpathSync(os.homedir())}`,
-      '-D',
-      `CACHE_DIR=${fs.realpathSync(execSync(`getconf DARWIN_USER_CACHE_DIR`).toString().trim())}`,
-    ];
+    // use interactive mode and auto-remove container on exit
+    // run init binary inside container to forward signals & reap zombies
+    const args = ['run', '-i', '--rm', '--init', '--workdir', containerWorkdir];
 
-    // Add included directories from the workspace context
-    // Always add 5 INCLUDE_DIR parameters to ensure .sb files can reference them
-    const MAX_INCLUDE_DIRS = 5;
-    const targetDir = fs.realpathSync(cliConfig?.getTargetDir() || '');
-    const includedDirs: string[] = [];
+    // add custom flags from SANDBOX_FLAGS
+    if (process.env.SANDBOX_FLAGS) {
+      const flags = parse(process.env.SANDBOX_FLAGS, process.env).filter(
+        (f): f is string => typeof f === 'string',
+      );
+      args.push(...flags);
+    }
 
-    if (cliConfig) {
-      const workspaceContext = cliConfig.getWorkspaceContext();
-      const directories = workspaceContext.getDirectories();
+    // add TTY only if stdin is TTY as well, i.e. for piped input don't init TTY in container
+    if (process.stdin.isTTY) {
+      args.push('-t');
+    }
 
-      // Filter out TARGET_DIR
-      for (const dir of directories) {
-        const realDir = fs.realpathSync(dir);
-        if (realDir !== targetDir) {
-          includedDirs.push(realDir);
+    // mount current directory as working directory in sandbox (set via --workdir)
+    args.push('--volume', `${workdir}:${containerWorkdir}`);
+
+    // mount user settings directory inside container, after creating if missing
+    // note user/home changes inside sandbox and we mount at BOTH paths for consistency
+    const userSettingsDirOnHost = USER_SETTINGS_DIR;
+    const userSettingsDirInSandbox = getContainerPath(
+      `/home/node/${SETTINGS_DIRECTORY_NAME}`,
+    );
+    if (!fs.existsSync(userSettingsDirOnHost)) {
+      fs.mkdirSync(userSettingsDirOnHost);
+    }
+    args.push(
+      '--volume',
+      `${userSettingsDirOnHost}:${userSettingsDirInSandbox}`,
+    );
+    if (userSettingsDirInSandbox !== userSettingsDirOnHost) {
+      args.push(
+        '--volume',
+        `${userSettingsDirOnHost}:${getContainerPath(userSettingsDirOnHost)}`,
+      );
+    }
+
+    // mount os.tmpdir() as os.tmpdir() inside container
+    args.push('--volume', `${os.tmpdir()}:${getContainerPath(os.tmpdir())}`);
+
+    // mount gcloud config directory if it exists
+    const gcloudConfigDir = path.join(os.homedir(), '.config', 'gcloud');
+    if (fs.existsSync(gcloudConfigDir)) {
+      args.push(
+        '--volume',
+        `${gcloudConfigDir}:${getContainerPath(gcloudConfigDir)}:ro`,
+      );
+    }
+
+    // mount ADC file if GOOGLE_APPLICATION_CREDENTIALS is set
+    if (process.env.GOOGLE_APPLICATION_CREDENTIALS) {
+      const adcFile = process.env.GOOGLE_APPLICATION_CREDENTIALS;
+      if (fs.existsSync(adcFile)) {
+        args.push('--volume', `${adcFile}:${getContainerPath(adcFile)}:ro`);
+        args.push(
+          '--env',
+          `GOOGLE_APPLICATION_CREDENTIALS=${getContainerPath(adcFile)}`,
+        );
+      }
+    }
+
+    // mount paths listed in SANDBOX_MOUNTS
+    if (process.env.SANDBOX_MOUNTS) {
+      for (let mount of process.env.SANDBOX_MOUNTS.split(',')) {
+        if (mount.trim()) {
+          // parse mount as from:to:opts
+          let [from, to, opts] = mount.trim().split(':');
+          to = to || from; // default to mount at same path inside container
+          opts = opts || 'ro'; // default to read-only
+          mount = `${from}:${to}:${opts}`;
+          // check that from path is absolute
+          if (!path.isAbsolute(from)) {
+            console.error(
+              `ERROR: path '${from}' listed in SANDBOX_MOUNTS must be absolute`,
+            );
+            process.exit(1);
+          }
+          // check that from path exists on host
+          if (!fs.existsSync(from)) {
+            console.error(
+              `ERROR: missing mount path '${from}' listed in SANDBOX_MOUNTS`,
+            );
+            process.exit(1);
+          }
+          console.error(`SANDBOX_MOUNTS: ${from} -> ${to} (${opts})`);
+          args.push('--volume', mount);
         }
       }
     }
 
-    for (let i = 0; i < MAX_INCLUDE_DIRS; i++) {
-      let dirPath = '/dev/null'; // Default to a safe path that won't cause issues
+    // expose env-specified ports on the sandbox
+    ports().forEach((p) => args.push('--publish', `${p}:${p}`));
 
-      if (i < includedDirs.length) {
-        dirPath = includedDirs[i];
-      }
-
-      args.push('-D', `INCLUDE_DIR_${i}=${dirPath}`);
+    // if DEBUG is set, expose debugging port
+    if (process.env.DEBUG) {
+      const debugPort = process.env.DEBUG_PORT || '9229';
+      args.push(`--publish`, `${debugPort}:${debugPort}`);
     }
 
-    args.push(
-      '-f',
-      profileFile,
-      'sh',
-      '-c',
-      [
-        `SANDBOX=sandbox-exec`,
-        `NODE_OPTIONS="${nodeOptions}"`,
-        ...process.argv.map((arg) => quote([arg])),
-      ].join(' '),
-    );
-    // start and set up proxy if GEMINI_SANDBOX_PROXY_COMMAND is set
+    // copy proxy environment variables, replacing localhost with SANDBOX_PROXY_NAME
+    // copy as both upper-case and lower-case as is required by some utilities
+    // GEMINI_SANDBOX_PROXY_COMMAND implies HTTPS_PROXY unless HTTP_PROXY is set
     const proxyCommand = process.env.GEMINI_SANDBOX_PROXY_COMMAND;
-    let proxyProcess: ChildProcess | undefined = undefined;
-    let sandboxProcess: ChildProcess | undefined = undefined;
-    const sandboxEnv = { ...process.env };
+
     if (proxyCommand) {
-      const proxy =
+      let proxy =
         process.env.HTTPS_PROXY ||
         process.env.https_proxy ||
         process.env.HTTP_PROXY ||
         process.env.http_proxy ||
         'http://localhost:8877';
-      sandboxEnv['HTTPS_PROXY'] = proxy;
-      sandboxEnv['https_proxy'] = proxy; // lower-case can be required, e.g. for curl
-      sandboxEnv['HTTP_PROXY'] = proxy;
-      sandboxEnv['http_proxy'] = proxy;
+      proxy = proxy.replace('localhost', SANDBOX_PROXY_NAME);
+      if (proxy) {
+        args.push('--env', `HTTPS_PROXY=${proxy}`);
+        args.push('--env', `https_proxy=${proxy}`); // lower-case can be required, e.g. for curl
+        args.push('--env', `HTTP_PROXY=${proxy}`);
+        args.push('--env', `http_proxy=${proxy}`);
+      }
       const noProxy = process.env.NO_PROXY || process.env.no_proxy;
       if (noProxy) {
-        sandboxEnv['NO_PROXY'] = noProxy;
-        sandboxEnv['no_proxy'] = noProxy;
+        args.push('--env', `NO_PROXY=${noProxy}`);
+        args.push('--env', `no_proxy=${noProxy}`);
       }
-      proxyProcess = spawn(proxyCommand, {
+
+      // if using proxy, switch to internal networking through proxy
+      if (proxy) {
+        execSync(
+          `${config.command} network inspect ${SANDBOX_NETWORK_NAME} || ${config.command} network create --internal ${SANDBOX_NETWORK_NAME}`,
+        );
+        args.push('--network', SANDBOX_NETWORK_NAME);
+        // if proxy command is set, create a separate network w/ host access (i.e. non-internal)
+        // we will run proxy in its own container connected to both host network and internal network
+        // this allows proxy to work even on rootless podman on macos with host<->vm<->container isolation
+        if (proxyCommand) {
+          execSync(
+            `${config.command} network inspect ${SANDBOX_PROXY_NAME} || ${config.command} network create ${SANDBOX_PROXY_NAME}`,
+          );
+        }
+      }
+    }
+
+    // name container after image, plus numeric suffix to avoid conflicts
+    const imageName = parseImageName(image);
+    let index = 0;
+    const containerNameCheck = execSync(
+      `${config.command} ps -a --format "{{.Names}}"`,
+    )
+      .toString()
+      .trim();
+    while (containerNameCheck.includes(`${imageName}-${index}`)) {
+      index++;
+    }
+    const containerName = `${imageName}-${index}`;
+    args.push('--name', containerName, '--hostname', containerName);
+
+    // copy GEMINI_API_KEY(s)
+    if (process.env.GEMINI_API_KEY) {
+      args.push('--env', `GEMINI_API_KEY=${process.env.GEMINI_API_KEY}`);
+    }
+    if (process.env.GOOGLE_API_KEY) {
+      args.push('--env', `GOOGLE_API_KEY=${process.env.GOOGLE_API_KEY}`);
+    }
+
+    // copy GOOGLE_GENAI_USE_VERTEXAI
+    if (process.env.GOOGLE_GENAI_USE_VERTEXAI) {
+      args.push(
+        '--env',
+        `GOOGLE_GENAI_USE_VERTEXAI=${process.env.GOOGLE_GENAI_USE_VERTEXAI}`,
+      );
+    }
+
+    // copy GOOGLE_GENAI_USE_GCA
+    if (process.env.GOOGLE_GENAI_USE_GCA) {
+      args.push(
+        '--env',
+        `GOOGLE_GENAI_USE_GCA=${process.env.GOOGLE_GENAI_USE_GCA}`,
+      );
+    }
+
+    // copy GOOGLE_CLOUD_PROJECT
+    if (process.env.GOOGLE_CLOUD_PROJECT) {
+      args.push(
+        '--env',
+        `GOOGLE_CLOUD_PROJECT=${process.env.GOOGLE_CLOUD_PROJECT}`,
+      );
+    }
+
+    // copy GOOGLE_CLOUD_LOCATION
+    if (process.env.GOOGLE_CLOUD_LOCATION) {
+      args.push(
+        '--env',
+        `GOOGLE_CLOUD_LOCATION=${process.env.GOOGLE_CLOUD_LOCATION}`,
+      );
+    }
+
+    // copy GEMINI_MODEL
+    if (process.env.GEMINI_MODEL) {
+      args.push('--env', `GEMINI_MODEL=${process.env.GEMINI_MODEL}`);
+    }
+
+    // copy TERM and COLORTERM to try to maintain terminal setup
+    if (process.env.TERM) {
+      args.push('--env', `TERM=${process.env.TERM}`);
+    }
+    if (process.env.COLORTERM) {
+      args.push('--env', `COLORTERM=${process.env.COLORTERM}`);
+    }
+
+    // copy VIRTUAL_ENV if under working directory
+    // also mount-replace VIRTUAL_ENV directory with <project_settings>/sandbox.venv
+    // sandbox can then set up this new VIRTUAL_ENV directory using sandbox.bashrc (see below)
+    // directory will be empty if not set up, which is still preferable to having host binaries
+    if (
+      process.env.VIRTUAL_ENV?.toLowerCase().startsWith(workdir.toLowerCase())
+    ) {
+      const sandboxVenvPath = path.resolve(
+        SETTINGS_DIRECTORY_NAME,
+        'sandbox.venv',
+      );
+      if (!fs.existsSync(sandboxVenvPath)) {
+        fs.mkdirSync(sandboxVenvPath, { recursive: true });
+      }
+      args.push(
+        '--volume',
+        `${sandboxVenvPath}:${getContainerPath(process.env.VIRTUAL_ENV)}`,
+      );
+      args.push(
+        '--env',
+        `VIRTUAL_ENV=${getContainerPath(process.env.VIRTUAL_ENV)}`,
+      );
+    }
+
+    // copy additional environment variables from SANDBOX_ENV
+    if (process.env.SANDBOX_ENV) {
+      for (let env of process.env.SANDBOX_ENV.split(',')) {
+        if ((env = env.trim())) {
+          if (env.includes('=')) {
+            console.error(`SANDBOX_ENV: ${env}`);
+            args.push('--env', env);
+          } else {
+            console.error(
+              'ERROR: SANDBOX_ENV must be a comma-separated list of key=value pairs',
+            );
+            process.exit(1);
+          }
+        }
+      }
+    }
+
+    // copy NODE_OPTIONS
+    const existingNodeOptions = process.env.NODE_OPTIONS || '';
+    const allNodeOptions = [
+      ...(existingNodeOptions ? [existingNodeOptions] : []),
+      ...nodeArgs,
+    ].join(' ');
+
+    if (allNodeOptions.length > 0) {
+      args.push('--env', `NODE_OPTIONS="${allNodeOptions}"`);
+    }
+
+    // set SANDBOX as container name
+    args.push('--env', `SANDBOX=${containerName}`);
+
+    // for podman only, use empty --authfile to skip unnecessary auth refresh overhead
+    if (config.command === 'podman') {
+      const emptyAuthFilePath = path.join(os.tmpdir(), 'empty_auth.json');
+      fs.writeFileSync(emptyAuthFilePath, '{}', 'utf-8');
+      args.push('--authfile', emptyAuthFilePath);
+    }
+
+    // Determine if the current user's UID/GID should be passed to the sandbox.
+    // See shouldUseCurrentUserInSandbox for more details.
+    let userFlag = '';
+    const finalEntrypoint = entrypoint(workdir);
+
+    if (process.env.GEMINI_CLI_INTEGRATION_TEST === 'true') {
+      args.push('--user', 'root');
+      userFlag = '--user root';
+    } else if (await shouldUseCurrentUserInSandbox()) {
+      // For the user-creation logic to work, the container must start as root.
+      // The entrypoint script then handles dropping privileges to the correct user.
+      args.push('--user', 'root');
+
+      const uid = execSync('id -u').toString().trim();
+      const gid = execSync('id -g').toString().trim();
+
+      // Instead of passing --user to the main sandbox container, we let it
+      // start as root, then create a user with the host's UID/GID, and
+      // finally switch to that user to run the gemini process. This is
+      // necessary on Linux to ensure the user exists within the
+      // container's /etc/passwd file, which is required by os.userInfo().
+      const username = 'gemini';
+      const homeDir = getContainerPath(os.homedir());
+
+      const setupUserCommands = [
+        // Use -f with groupadd to avoid errors if the group already exists.
+        `groupadd -f -g ${gid} ${username}`,
+        // Create user only if it doesn't exist. Use -o for non-unique UID.
+        `id -u ${username} &>/dev/null || useradd -o -u ${uid} -g ${gid} -d ${homeDir} -s /bin/bash ${username}`,
+      ].join(' && ');
+
+      const originalCommand = finalEntrypoint[2];
+      const escapedOriginalCommand = originalCommand.replace(/'/g, "'\\''");
+
+      // Use `su -p` to preserve the environment.
+      const suCommand = `su -p ${username} -c '${escapedOriginalCommand}'`;
+
+      // The entrypoint is always `['bash', '-c', '<command>']`, so we modify the command part.
+      finalEntrypoint[2] = `${setupUserCommands} && ${suCommand}`;
+
+      // We still need userFlag for the simpler proxy container, which does not have this issue.
+      userFlag = `--user ${uid}:${gid}`;
+      // When forcing a UID in the sandbox, $HOME can be reset to '/', so we copy $HOME as well.
+      args.push('--env', `HOME=${os.homedir()}`);
+    }
+
+    // push container image name
+    args.push(image);
+
+    // push container entrypoint (including args)
+    args.push(...finalEntrypoint);
+
+    // start and set up proxy if GEMINI_SANDBOX_PROXY_COMMAND is set
+    let proxyProcess: ChildProcess | undefined = undefined;
+    let sandboxProcess: ChildProcess | undefined = undefined;
+
+    if (proxyCommand) {
+      // run proxyCommand in its own container
+      const proxyContainerCommand = `${config.command} run --rm --init ${userFlag} --name ${SANDBOX_PROXY_NAME} --network ${SANDBOX_PROXY_NAME} -p 8877:8877 -v ${process.cwd()}:${workdir} --workdir ${workdir} ${image} ${proxyCommand}`;
+      proxyProcess = spawn(proxyContainerCommand, {
         stdio: ['ignore', 'pipe', 'pipe'],
         shell: true,
         detached: true,
       });
       // install handlers to stop proxy on exit/signal
       const stopProxy = () => {
-        console.log('stopping proxy ...');
-        if (proxyProcess?.pid) {
-          process.kill(-proxyProcess.pid, 'SIGTERM');
-        }
+        console.log('stopping proxy container ...');
+        execSync(`${config.command} rm -f ${SANDBOX_PROXY_NAME}`);
       };
       process.on('exit', stopProxy);
       process.on('SIGINT', stopProxy);
@@ -308,11 +754,11 @@ export async function start_sandbox(
       //   console.info(data.toString());
       // });
       proxyProcess.stderr?.on('data', (data) => {
-        console.error(data.toString());
+        console.error(data.toString().trim());
       });
       proxyProcess.on('close', (code, signal) => {
         console.error(
-          `ERROR: proxy command '${proxyCommand}' exited with code ${code}, signal ${signal}`,
+          `ERROR: proxy container command '${proxyContainerCommand}' exited with code ${code}, signal ${signal}`,
         );
         if (sandboxProcess?.pid) {
           process.kill(-sandboxProcess.pid, 'SIGTERM');
@@ -323,467 +769,35 @@ export async function start_sandbox(
       await execAsync(
         `until timeout 0.25 curl -s http://localhost:8877; do sleep 0.25; done`,
       );
+      // connect proxy container to sandbox network
+      // (workaround for older versions of docker that don't support multiple --network args)
+      await execAsync(
+        `${config.command} network connect ${SANDBOX_NETWORK_NAME} ${SANDBOX_PROXY_NAME}`,
+      );
     }
+
     // spawn child and let it inherit stdio
     sandboxProcess = spawn(config.command, args, {
       stdio: 'inherit',
     });
-    await new Promise((resolve) => sandboxProcess?.on('close', resolve));
-    return;
-  }
 
-  console.error(`hopping into sandbox (command: ${config.command}) ...`);
+    sandboxProcess.on('error', (err) => {
+      console.error('Sandbox process error:', err);
+    });
 
-  // determine full path for gemini-cli to distinguish linked vs installed setting
-  const gcPath = fs.realpathSync(process.argv[1]);
-
-  const projectSandboxDockerfile = path.join(
-    SETTINGS_DIRECTORY_NAME,
-    'sandbox.Dockerfile',
-  );
-  const isCustomProjectSandbox = fs.existsSync(projectSandboxDockerfile);
-
-  const image = config.image;
-  const workdir = path.resolve(process.cwd());
-  const containerWorkdir = getContainerPath(workdir);
-
-  // if BUILD_SANDBOX is set, then call scripts/build_sandbox.js under gemini-cli repo
-  //
-  // note this can only be done with binary linked from gemini-cli repo
-  if (process.env.BUILD_SANDBOX) {
-    if (!gcPath.includes('gemini-cli/packages/')) {
-      console.error(
-        'ERROR: cannot build sandbox using installed gemini binary; ' +
-          'run `npm link ./packages/cli` under gemini-cli repo to switch to linked binary.',
-      );
-      process.exit(1);
-    } else {
-      console.error('building sandbox ...');
-      const gcRoot = gcPath.split('/packages/')[0];
-      // if project folder has sandbox.Dockerfile under project settings folder, use that
-      let buildArgs = '';
-      const projectSandboxDockerfile = path.join(
-        SETTINGS_DIRECTORY_NAME,
-        'sandbox.Dockerfile',
-      );
-      if (isCustomProjectSandbox) {
-        console.error(`using ${projectSandboxDockerfile} for sandbox`);
-        buildArgs += `-f ${path.resolve(projectSandboxDockerfile)} -i ${image}`;
-      }
-      execSync(
-        `cd ${gcRoot} && node scripts/build_sandbox.js -s ${buildArgs}`,
-        {
-          stdio: 'inherit',
-          env: {
-            ...process.env,
-            GEMINI_SANDBOX: config.command, // in case sandbox is enabled via flags (see config.ts under cli package)
-          },
-        },
-      );
-    }
-  }
-
-  // stop if image is missing
-  if (!(await ensureSandboxImageIsPresent(config.command, image))) {
-    const remedy =
-      image === LOCAL_DEV_SANDBOX_IMAGE_NAME
-        ? 'Try running `npm run build:all` or `npm run build:sandbox` under the gemini-cli repo to build it locally, or check the image name and your network connection.'
-        : 'Please check the image name, your network connection, or notify gemini-cli-dev@google.com if the issue persists.';
-    console.error(
-      `ERROR: Sandbox image '${image}' is missing or could not be pulled. ${remedy}`,
-    );
-    process.exit(1);
-  }
-
-  // use interactive mode and auto-remove container on exit
-  // run init binary inside container to forward signals & reap zombies
-  const args = ['run', '-i', '--rm', '--init', '--workdir', containerWorkdir];
-
-  // add custom flags from SANDBOX_FLAGS
-  if (process.env.SANDBOX_FLAGS) {
-    const flags = parse(process.env.SANDBOX_FLAGS, process.env).filter(
-      (f): f is string => typeof f === 'string',
-    );
-    args.push(...flags);
-  }
-
-  // add TTY only if stdin is TTY as well, i.e. for piped input don't init TTY in container
-  if (process.stdin.isTTY) {
-    args.push('-t');
-  }
-
-  // mount current directory as working directory in sandbox (set via --workdir)
-  args.push('--volume', `${workdir}:${containerWorkdir}`);
-
-  // mount user settings directory inside container, after creating if missing
-  // note user/home changes inside sandbox and we mount at BOTH paths for consistency
-  const userSettingsDirOnHost = USER_SETTINGS_DIR;
-  const userSettingsDirInSandbox = getContainerPath(
-    `/home/node/${SETTINGS_DIRECTORY_NAME}`,
-  );
-  if (!fs.existsSync(userSettingsDirOnHost)) {
-    fs.mkdirSync(userSettingsDirOnHost);
-  }
-  args.push('--volume', `${userSettingsDirOnHost}:${userSettingsDirInSandbox}`);
-  if (userSettingsDirInSandbox !== userSettingsDirOnHost) {
-    args.push(
-      '--volume',
-      `${userSettingsDirOnHost}:${getContainerPath(userSettingsDirOnHost)}`,
-    );
-  }
-
-  // mount os.tmpdir() as os.tmpdir() inside container
-  args.push('--volume', `${os.tmpdir()}:${getContainerPath(os.tmpdir())}`);
-
-  // mount gcloud config directory if it exists
-  const gcloudConfigDir = path.join(os.homedir(), '.config', 'gcloud');
-  if (fs.existsSync(gcloudConfigDir)) {
-    args.push(
-      '--volume',
-      `${gcloudConfigDir}:${getContainerPath(gcloudConfigDir)}:ro`,
-    );
-  }
-
-  // mount ADC file if GOOGLE_APPLICATION_CREDENTIALS is set
-  if (process.env.GOOGLE_APPLICATION_CREDENTIALS) {
-    const adcFile = process.env.GOOGLE_APPLICATION_CREDENTIALS;
-    if (fs.existsSync(adcFile)) {
-      args.push('--volume', `${adcFile}:${getContainerPath(adcFile)}:ro`);
-      args.push(
-        '--env',
-        `GOOGLE_APPLICATION_CREDENTIALS=${getContainerPath(adcFile)}`,
-      );
-    }
-  }
-
-  // mount paths listed in SANDBOX_MOUNTS
-  if (process.env.SANDBOX_MOUNTS) {
-    for (let mount of process.env.SANDBOX_MOUNTS.split(',')) {
-      if (mount.trim()) {
-        // parse mount as from:to:opts
-        let [from, to, opts] = mount.trim().split(':');
-        to = to || from; // default to mount at same path inside container
-        opts = opts || 'ro'; // default to read-only
-        mount = `${from}:${to}:${opts}`;
-        // check that from path is absolute
-        if (!path.isAbsolute(from)) {
-          console.error(
-            `ERROR: path '${from}' listed in SANDBOX_MOUNTS must be absolute`,
+    await new Promise<void>((resolve) => {
+      sandboxProcess?.on('close', (code, signal) => {
+        if (code !== 0) {
+          console.log(
+            `Sandbox process exited with code: ${code}, signal: ${signal}`,
           );
-          process.exit(1);
         }
-        // check that from path exists on host
-        if (!fs.existsSync(from)) {
-          console.error(
-            `ERROR: missing mount path '${from}' listed in SANDBOX_MOUNTS`,
-          );
-          process.exit(1);
-        }
-        console.error(`SANDBOX_MOUNTS: ${from} -> ${to} (${opts})`);
-        args.push('--volume', mount);
-      }
-    }
-  }
-
-  // expose env-specified ports on the sandbox
-  ports().forEach((p) => args.push('--publish', `${p}:${p}`));
-
-  // if DEBUG is set, expose debugging port
-  if (process.env.DEBUG) {
-    const debugPort = process.env.DEBUG_PORT || '9229';
-    args.push(`--publish`, `${debugPort}:${debugPort}`);
-  }
-
-  // copy proxy environment variables, replacing localhost with SANDBOX_PROXY_NAME
-  // copy as both upper-case and lower-case as is required by some utilities
-  // GEMINI_SANDBOX_PROXY_COMMAND implies HTTPS_PROXY unless HTTP_PROXY is set
-  const proxyCommand = process.env.GEMINI_SANDBOX_PROXY_COMMAND;
-
-  if (proxyCommand) {
-    let proxy =
-      process.env.HTTPS_PROXY ||
-      process.env.https_proxy ||
-      process.env.HTTP_PROXY ||
-      process.env.http_proxy ||
-      'http://localhost:8877';
-    proxy = proxy.replace('localhost', SANDBOX_PROXY_NAME);
-    if (proxy) {
-      args.push('--env', `HTTPS_PROXY=${proxy}`);
-      args.push('--env', `https_proxy=${proxy}`); // lower-case can be required, e.g. for curl
-      args.push('--env', `HTTP_PROXY=${proxy}`);
-      args.push('--env', `http_proxy=${proxy}`);
-    }
-    const noProxy = process.env.NO_PROXY || process.env.no_proxy;
-    if (noProxy) {
-      args.push('--env', `NO_PROXY=${noProxy}`);
-      args.push('--env', `no_proxy=${noProxy}`);
-    }
-
-    // if using proxy, switch to internal networking through proxy
-    if (proxy) {
-      execSync(
-        `${config.command} network inspect ${SANDBOX_NETWORK_NAME} || ${config.command} network create --internal ${SANDBOX_NETWORK_NAME}`,
-      );
-      args.push('--network', SANDBOX_NETWORK_NAME);
-      // if proxy command is set, create a separate network w/ host access (i.e. non-internal)
-      // we will run proxy in its own container connected to both host network and internal network
-      // this allows proxy to work even on rootless podman on macos with host<->vm<->container isolation
-      if (proxyCommand) {
-        execSync(
-          `${config.command} network inspect ${SANDBOX_PROXY_NAME} || ${config.command} network create ${SANDBOX_PROXY_NAME}`,
-        );
-      }
-    }
-  }
-
-  // name container after image, plus numeric suffix to avoid conflicts
-  const imageName = parseImageName(image);
-  let index = 0;
-  const containerNameCheck = execSync(
-    `${config.command} ps -a --format "{{.Names}}"`,
-  )
-    .toString()
-    .trim();
-  while (containerNameCheck.includes(`${imageName}-${index}`)) {
-    index++;
-  }
-  const containerName = `${imageName}-${index}`;
-  args.push('--name', containerName, '--hostname', containerName);
-
-  // copy GEMINI_API_KEY(s)
-  if (process.env.GEMINI_API_KEY) {
-    args.push('--env', `GEMINI_API_KEY=${process.env.GEMINI_API_KEY}`);
-  }
-  if (process.env.GOOGLE_API_KEY) {
-    args.push('--env', `GOOGLE_API_KEY=${process.env.GOOGLE_API_KEY}`);
-  }
-
-  // copy GOOGLE_GENAI_USE_VERTEXAI
-  if (process.env.GOOGLE_GENAI_USE_VERTEXAI) {
-    args.push(
-      '--env',
-      `GOOGLE_GENAI_USE_VERTEXAI=${process.env.GOOGLE_GENAI_USE_VERTEXAI}`,
-    );
-  }
-
-  // copy GOOGLE_GENAI_USE_GCA
-  if (process.env.GOOGLE_GENAI_USE_GCA) {
-    args.push(
-      '--env',
-      `GOOGLE_GENAI_USE_GCA=${process.env.GOOGLE_GENAI_USE_GCA}`,
-    );
-  }
-
-  // copy GOOGLE_CLOUD_PROJECT
-  if (process.env.GOOGLE_CLOUD_PROJECT) {
-    args.push(
-      '--env',
-      `GOOGLE_CLOUD_PROJECT=${process.env.GOOGLE_CLOUD_PROJECT}`,
-    );
-  }
-
-  // copy GOOGLE_CLOUD_LOCATION
-  if (process.env.GOOGLE_CLOUD_LOCATION) {
-    args.push(
-      '--env',
-      `GOOGLE_CLOUD_LOCATION=${process.env.GOOGLE_CLOUD_LOCATION}`,
-    );
-  }
-
-  // copy GEMINI_MODEL
-  if (process.env.GEMINI_MODEL) {
-    args.push('--env', `GEMINI_MODEL=${process.env.GEMINI_MODEL}`);
-  }
-
-  // copy TERM and COLORTERM to try to maintain terminal setup
-  if (process.env.TERM) {
-    args.push('--env', `TERM=${process.env.TERM}`);
-  }
-  if (process.env.COLORTERM) {
-    args.push('--env', `COLORTERM=${process.env.COLORTERM}`);
-  }
-
-  // copy VIRTUAL_ENV if under working directory
-  // also mount-replace VIRTUAL_ENV directory with <project_settings>/sandbox.venv
-  // sandbox can then set up this new VIRTUAL_ENV directory using sandbox.bashrc (see below)
-  // directory will be empty if not set up, which is still preferable to having host binaries
-  if (
-    process.env.VIRTUAL_ENV?.toLowerCase().startsWith(workdir.toLowerCase())
-  ) {
-    const sandboxVenvPath = path.resolve(
-      SETTINGS_DIRECTORY_NAME,
-      'sandbox.venv',
-    );
-    if (!fs.existsSync(sandboxVenvPath)) {
-      fs.mkdirSync(sandboxVenvPath, { recursive: true });
-    }
-    args.push(
-      '--volume',
-      `${sandboxVenvPath}:${getContainerPath(process.env.VIRTUAL_ENV)}`,
-    );
-    args.push(
-      '--env',
-      `VIRTUAL_ENV=${getContainerPath(process.env.VIRTUAL_ENV)}`,
-    );
-  }
-
-  // copy additional environment variables from SANDBOX_ENV
-  if (process.env.SANDBOX_ENV) {
-    for (let env of process.env.SANDBOX_ENV.split(',')) {
-      if ((env = env.trim())) {
-        if (env.includes('=')) {
-          console.error(`SANDBOX_ENV: ${env}`);
-          args.push('--env', env);
-        } else {
-          console.error(
-            'ERROR: SANDBOX_ENV must be a comma-separated list of key=value pairs',
-          );
-          process.exit(1);
-        }
-      }
-    }
-  }
-
-  // copy NODE_OPTIONS
-  const existingNodeOptions = process.env.NODE_OPTIONS || '';
-  const allNodeOptions = [
-    ...(existingNodeOptions ? [existingNodeOptions] : []),
-    ...nodeArgs,
-  ].join(' ');
-
-  if (allNodeOptions.length > 0) {
-    args.push('--env', `NODE_OPTIONS="${allNodeOptions}"`);
-  }
-
-  // set SANDBOX as container name
-  args.push('--env', `SANDBOX=${containerName}`);
-
-  // for podman only, use empty --authfile to skip unnecessary auth refresh overhead
-  if (config.command === 'podman') {
-    const emptyAuthFilePath = path.join(os.tmpdir(), 'empty_auth.json');
-    fs.writeFileSync(emptyAuthFilePath, '{}', 'utf-8');
-    args.push('--authfile', emptyAuthFilePath);
-  }
-
-  // Determine if the current user's UID/GID should be passed to the sandbox.
-  // See shouldUseCurrentUserInSandbox for more details.
-  let userFlag = '';
-  const finalEntrypoint = entrypoint(workdir);
-
-  if (process.env.GEMINI_CLI_INTEGRATION_TEST === 'true') {
-    args.push('--user', 'root');
-    userFlag = '--user root';
-  } else if (await shouldUseCurrentUserInSandbox()) {
-    // For the user-creation logic to work, the container must start as root.
-    // The entrypoint script then handles dropping privileges to the correct user.
-    args.push('--user', 'root');
-
-    const uid = execSync('id -u').toString().trim();
-    const gid = execSync('id -g').toString().trim();
-
-    // Instead of passing --user to the main sandbox container, we let it
-    // start as root, then create a user with the host's UID/GID, and
-    // finally switch to that user to run the gemini process. This is
-    // necessary on Linux to ensure the user exists within the
-    // container's /etc/passwd file, which is required by os.userInfo().
-    const username = 'gemini';
-    const homeDir = getContainerPath(os.homedir());
-
-    const setupUserCommands = [
-      // Use -f with groupadd to avoid errors if the group already exists.
-      `groupadd -f -g ${gid} ${username}`,
-      // Create user only if it doesn't exist. Use -o for non-unique UID.
-      `id -u ${username} &>/dev/null || useradd -o -u ${uid} -g ${gid} -d ${homeDir} -s /bin/bash ${username}`,
-    ].join(' && ');
-
-    const originalCommand = finalEntrypoint[2];
-    const escapedOriginalCommand = originalCommand.replace(/'/g, "'\\''");
-
-    // Use `su -p` to preserve the environment.
-    const suCommand = `su -p ${username} -c '${escapedOriginalCommand}'`;
-
-    // The entrypoint is always `['bash', '-c', '<command>']`, so we modify the command part.
-    finalEntrypoint[2] = `${setupUserCommands} && ${suCommand}`;
-
-    // We still need userFlag for the simpler proxy container, which does not have this issue.
-    userFlag = `--user ${uid}:${gid}`;
-    // When forcing a UID in the sandbox, $HOME can be reset to '/', so we copy $HOME as well.
-    args.push('--env', `HOME=${os.homedir()}`);
-  }
-
-  // push container image name
-  args.push(image);
-
-  // push container entrypoint (including args)
-  args.push(...finalEntrypoint);
-
-  // start and set up proxy if GEMINI_SANDBOX_PROXY_COMMAND is set
-  let proxyProcess: ChildProcess | undefined = undefined;
-  let sandboxProcess: ChildProcess | undefined = undefined;
-
-  if (proxyCommand) {
-    // run proxyCommand in its own container
-    const proxyContainerCommand = `${config.command} run --rm --init ${userFlag} --name ${SANDBOX_PROXY_NAME} --network ${SANDBOX_PROXY_NAME} -p 8877:8877 -v ${process.cwd()}:${workdir} --workdir ${workdir} ${image} ${proxyCommand}`;
-    proxyProcess = spawn(proxyContainerCommand, {
-      stdio: ['ignore', 'pipe', 'pipe'],
-      shell: true,
-      detached: true,
+        resolve();
+      });
     });
-    // install handlers to stop proxy on exit/signal
-    const stopProxy = () => {
-      console.log('stopping proxy container ...');
-      execSync(`${config.command} rm -f ${SANDBOX_PROXY_NAME}`);
-    };
-    process.on('exit', stopProxy);
-    process.on('SIGINT', stopProxy);
-    process.on('SIGTERM', stopProxy);
-
-    // commented out as it disrupts ink rendering
-    // proxyProcess.stdout?.on('data', (data) => {
-    //   console.info(data.toString());
-    // });
-    proxyProcess.stderr?.on('data', (data) => {
-      console.error(data.toString().trim());
-    });
-    proxyProcess.on('close', (code, signal) => {
-      console.error(
-        `ERROR: proxy container command '${proxyContainerCommand}' exited with code ${code}, signal ${signal}`,
-      );
-      if (sandboxProcess?.pid) {
-        process.kill(-sandboxProcess.pid, 'SIGTERM');
-      }
-      process.exit(1);
-    });
-    console.log('waiting for proxy to start ...');
-    await execAsync(
-      `until timeout 0.25 curl -s http://localhost:8877; do sleep 0.25; done`,
-    );
-    // connect proxy container to sandbox network
-    // (workaround for older versions of docker that don't support multiple --network args)
-    await execAsync(
-      `${config.command} network connect ${SANDBOX_NETWORK_NAME} ${SANDBOX_PROXY_NAME}`,
-    );
+  } finally {
+    patcher.cleanup();
   }
-
-  // spawn child and let it inherit stdio
-  sandboxProcess = spawn(config.command, args, {
-    stdio: 'inherit',
-  });
-
-  sandboxProcess.on('error', (err) => {
-    console.error('Sandbox process error:', err);
-  });
-
-  await new Promise<void>((resolve) => {
-    sandboxProcess?.on('close', (code, signal) => {
-      if (code !== 0) {
-        console.log(
-          `Sandbox process exited with code: ${code}, signal: ${signal}`,
-        );
-      }
-      resolve();
-    });
-  });
 }
 
 // Helper functions to ensure sandbox image is present

From 36750ca49b1b2fa43a3d7904416b876203a1850f Mon Sep 17 00:00:00 2001
From: Abhi <43648792+abhipatel12@users.noreply.github.com>
Date: Wed, 6 Aug 2025 20:34:38 -0400
Subject: [PATCH 032/107] feat(agent): Introduce Foundational Subagent
 Architecture (#1805)

Co-authored-by: Colt McAnlis <colton@google.com>
---
 packages/core/src/core/client.ts              | 110 +--
 packages/core/src/core/geminiChat.ts          |   3 +
 packages/core/src/core/subagent.test.ts       | 814 ++++++++++++++++++
 packages/core/src/core/subagent.ts            | 681 +++++++++++++++
 packages/core/src/tools/tool-registry.ts      |  16 +
 .../core/src/utils/environmentContext.test.ts | 205 +++++
 packages/core/src/utils/environmentContext.ts | 109 +++
 7 files changed, 1834 insertions(+), 104 deletions(-)
 create mode 100644 packages/core/src/core/subagent.test.ts
 create mode 100644 packages/core/src/core/subagent.ts
 create mode 100644 packages/core/src/utils/environmentContext.test.ts
 create mode 100644 packages/core/src/utils/environmentContext.ts

diff --git a/packages/core/src/core/client.ts b/packages/core/src/core/client.ts
index f8b9a7de..a16a72cc 100644
--- a/packages/core/src/core/client.ts
+++ b/packages/core/src/core/client.ts
@@ -7,14 +7,16 @@
 import {
   EmbedContentParameters,
   GenerateContentConfig,
-  Part,
   SchemaUnion,
   PartListUnion,
   Content,
   Tool,
   GenerateContentResponse,
 } from '@google/genai';
-import { getFolderStructure } from '../utils/getFolderStructure.js';
+import {
+  getDirectoryContextString,
+  getEnvironmentContext,
+} from '../utils/environmentContext.js';
 import {
   Turn,
   ServerGeminiStreamEvent,
@@ -182,112 +184,12 @@ export class GeminiClient {
 
     this.getChat().addHistory({
       role: 'user',
-      parts: [{ text: await this.getDirectoryContext() }],
+      parts: [{ text: await getDirectoryContextString(this.config) }],
     });
   }
 
-  private async getDirectoryContext(): Promise<string> {
-    const workspaceContext = this.config.getWorkspaceContext();
-    const workspaceDirectories = workspaceContext.getDirectories();
-
-    const folderStructures = await Promise.all(
-      workspaceDirectories.map((dir) =>
-        getFolderStructure(dir, {
-          fileService: this.config.getFileService(),
-        }),
-      ),
-    );
-
-    const folderStructure = folderStructures.join('\n');
-    const dirList = workspaceDirectories.map((dir) => `  - ${dir}`).join('\n');
-    const workingDirPreamble = `I'm currently working in the following directories:\n${dirList}\n Folder structures are as follows:\n${folderStructure}`;
-    return workingDirPreamble;
-  }
-
-  private async getEnvironment(): Promise<Part[]> {
-    const today = new Date().toLocaleDateString(undefined, {
-      weekday: 'long',
-      year: 'numeric',
-      month: 'long',
-      day: 'numeric',
-    });
-    const platform = process.platform;
-
-    const workspaceContext = this.config.getWorkspaceContext();
-    const workspaceDirectories = workspaceContext.getDirectories();
-
-    const folderStructures = await Promise.all(
-      workspaceDirectories.map((dir) =>
-        getFolderStructure(dir, {
-          fileService: this.config.getFileService(),
-        }),
-      ),
-    );
-
-    const folderStructure = folderStructures.join('\n');
-
-    let workingDirPreamble: string;
-    if (workspaceDirectories.length === 1) {
-      workingDirPreamble = `I'm currently working in the directory: ${workspaceDirectories[0]}`;
-    } else {
-      const dirList = workspaceDirectories
-        .map((dir) => `  - ${dir}`)
-        .join('\n');
-      workingDirPreamble = `I'm currently working in the following directories:\n${dirList}`;
-    }
-
-    const context = `
-  This is the Gemini CLI. We are setting up the context for our chat.
-  Today's date is ${today}.
-  My operating system is: ${platform}
-  ${workingDirPreamble}
-  Here is the folder structure of the current working directories:\n
-  ${folderStructure}
-          `.trim();
-
-    const initialParts: Part[] = [{ text: context }];
-    const toolRegistry = await this.config.getToolRegistry();
-
-    // Add full file context if the flag is set
-    if (this.config.getFullContext()) {
-      try {
-        const readManyFilesTool = toolRegistry.getTool('read_many_files');
-        if (readManyFilesTool) {
-          const invocation = readManyFilesTool.build({
-            paths: ['**/*'], // Read everything recursively
-            useDefaultExcludes: true, // Use default excludes
-          });
-
-          // Read all files in the target directory
-          const result = await invocation.execute(AbortSignal.timeout(30000));
-          if (result.llmContent) {
-            initialParts.push({
-              text: `\n--- Full File Context ---\n${result.llmContent}`,
-            });
-          } else {
-            console.warn(
-              'Full context requested, but read_many_files returned no content.',
-            );
-          }
-        } else {
-          console.warn(
-            'Full context requested, but read_many_files tool not found.',
-          );
-        }
-      } catch (error) {
-        // Not using reportError here as it's a startup/config phase, not a chat/generation phase error.
-        console.error('Error reading full file context:', error);
-        initialParts.push({
-          text: '\n--- Error reading full file context ---',
-        });
-      }
-    }
-
-    return initialParts;
-  }
-
   async startChat(extraHistory?: Content[]): Promise<GeminiChat> {
-    const envParts = await this.getEnvironment();
+    const envParts = await getEnvironmentContext(this.config);
     const toolRegistry = await this.config.getToolRegistry();
     const toolDeclarations = toolRegistry.getFunctionDeclarations();
     const tools: Tool[] = [{ functionDeclarations: toolDeclarations }];
diff --git a/packages/core/src/core/geminiChat.ts b/packages/core/src/core/geminiChat.ts
index 5f5b22e8..cff23d2d 100644
--- a/packages/core/src/core/geminiChat.ts
+++ b/packages/core/src/core/geminiChat.ts
@@ -242,6 +242,9 @@ export class GeminiChat {
     return null;
   }
 
+  setSystemInstruction(sysInstr: string) {
+    this.generationConfig.systemInstruction = sysInstr;
+  }
   /**
    * Sends a message to the model and returns the response.
    *
diff --git a/packages/core/src/core/subagent.test.ts b/packages/core/src/core/subagent.test.ts
new file mode 100644
index 00000000..889feb45
--- /dev/null
+++ b/packages/core/src/core/subagent.test.ts
@@ -0,0 +1,814 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { vi, describe, it, expect, beforeEach, Mock, afterEach } from 'vitest';
+import {
+  ContextState,
+  SubAgentScope,
+  SubagentTerminateMode,
+  PromptConfig,
+  ModelConfig,
+  RunConfig,
+  OutputConfig,
+  ToolConfig,
+} from './subagent.js';
+import { Config, ConfigParameters } from '../config/config.js';
+import { GeminiChat } from './geminiChat.js';
+import { createContentGenerator } from './contentGenerator.js';
+import { getEnvironmentContext } from '../utils/environmentContext.js';
+import { executeToolCall } from './nonInteractiveToolExecutor.js';
+import { ToolRegistry } from '../tools/tool-registry.js';
+import { DEFAULT_GEMINI_MODEL } from '../config/models.js';
+import {
+  Content,
+  FunctionCall,
+  FunctionDeclaration,
+  GenerateContentConfig,
+  Type,
+} from '@google/genai';
+import { ToolErrorType } from '../tools/tool-error.js';
+
+vi.mock('./geminiChat.js');
+vi.mock('./contentGenerator.js');
+vi.mock('../utils/environmentContext.js');
+vi.mock('./nonInteractiveToolExecutor.js');
+vi.mock('../ide/ide-client.js');
+
+async function createMockConfig(
+  toolRegistryMocks = {},
+): Promise<{ config: Config; toolRegistry: ToolRegistry }> {
+  const configParams: ConfigParameters = {
+    sessionId: 'test-session',
+    model: DEFAULT_GEMINI_MODEL,
+    targetDir: '.',
+    debugMode: false,
+    cwd: process.cwd(),
+  };
+  const config = new Config(configParams);
+  await config.initialize();
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  await config.refreshAuth('test-auth' as any);
+
+  // Mock ToolRegistry
+  const mockToolRegistry = {
+    getTool: vi.fn(),
+    getFunctionDeclarationsFiltered: vi.fn().mockReturnValue([]),
+    ...toolRegistryMocks,
+  } as unknown as ToolRegistry;
+
+  vi.spyOn(config, 'getToolRegistry').mockResolvedValue(mockToolRegistry);
+  return { config, toolRegistry: mockToolRegistry };
+}
+
+// Helper to simulate LLM responses (sequence of tool calls over multiple turns)
+const createMockStream = (
+  functionCallsList: Array<FunctionCall[] | 'stop'>,
+) => {
+  let index = 0;
+  return vi.fn().mockImplementation(() => {
+    const response = functionCallsList[index] || 'stop';
+    index++;
+    return (async function* () {
+      if (response === 'stop') {
+        // When stopping, the model might return text, but the subagent logic primarily cares about the absence of functionCalls.
+        yield { text: 'Done.' };
+      } else if (response.length > 0) {
+        yield { functionCalls: response };
+      } else {
+        yield { text: 'Done.' }; // Handle empty array also as stop
+      }
+    })();
+  });
+};
+
+describe('subagent.ts', () => {
+  describe('ContextState', () => {
+    it('should set and get values correctly', () => {
+      const context = new ContextState();
+      context.set('key1', 'value1');
+      context.set('key2', 123);
+      expect(context.get('key1')).toBe('value1');
+      expect(context.get('key2')).toBe(123);
+      expect(context.get_keys()).toEqual(['key1', 'key2']);
+    });
+
+    it('should return undefined for missing keys', () => {
+      const context = new ContextState();
+      expect(context.get('missing')).toBeUndefined();
+    });
+  });
+
+  describe('SubAgentScope', () => {
+    let mockSendMessageStream: Mock;
+
+    const defaultModelConfig: ModelConfig = {
+      model: 'gemini-1.5-flash-latest',
+      temp: 0.5, // Specific temp to test override
+      top_p: 1,
+    };
+
+    const defaultRunConfig: RunConfig = {
+      max_time_minutes: 5,
+      max_turns: 10,
+    };
+
+    beforeEach(async () => {
+      vi.clearAllMocks();
+
+      vi.mocked(getEnvironmentContext).mockResolvedValue([
+        { text: 'Env Context' },
+      ]);
+      vi.mocked(createContentGenerator).mockResolvedValue({
+        getGenerativeModel: vi.fn(),
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      } as any);
+
+      mockSendMessageStream = vi.fn();
+      // We mock the implementation of the constructor.
+      vi.mocked(GeminiChat).mockImplementation(
+        () =>
+          ({
+            sendMessageStream: mockSendMessageStream,
+          }) as unknown as GeminiChat,
+      );
+    });
+
+    afterEach(() => {
+      vi.restoreAllMocks();
+    });
+
+    // Helper to safely access generationConfig from mock calls
+    const getGenerationConfigFromMock = (
+      callIndex = 0,
+    ): GenerateContentConfig & { systemInstruction?: string | Content } => {
+      const callArgs = vi.mocked(GeminiChat).mock.calls[callIndex];
+      const generationConfig = callArgs?.[2];
+      // Ensure it's defined before proceeding
+      expect(generationConfig).toBeDefined();
+      if (!generationConfig) throw new Error('generationConfig is undefined');
+      return generationConfig as GenerateContentConfig & {
+        systemInstruction?: string | Content;
+      };
+    };
+
+    describe('create (Tool Validation)', () => {
+      const promptConfig: PromptConfig = { systemPrompt: 'Test prompt' };
+
+      it('should create a SubAgentScope successfully with minimal config', async () => {
+        const { config } = await createMockConfig();
+        const scope = await SubAgentScope.create(
+          'test-agent',
+          config,
+          promptConfig,
+          defaultModelConfig,
+          defaultRunConfig,
+        );
+        expect(scope).toBeInstanceOf(SubAgentScope);
+      });
+
+      it('should throw an error if a tool requires confirmation', async () => {
+        const mockTool = {
+          schema: { parameters: { type: Type.OBJECT, properties: {} } },
+          build: vi.fn().mockReturnValue({
+            shouldConfirmExecute: vi.fn().mockResolvedValue({
+              type: 'exec',
+              title: 'Confirm',
+              command: 'rm -rf /',
+            }),
+          }),
+        };
+
+        const { config } = await createMockConfig({
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          getTool: vi.fn().mockReturnValue(mockTool as any),
+        });
+
+        const toolConfig: ToolConfig = { tools: ['risky_tool'] };
+
+        await expect(
+          SubAgentScope.create(
+            'test-agent',
+            config,
+            promptConfig,
+            defaultModelConfig,
+            defaultRunConfig,
+            toolConfig,
+          ),
+        ).rejects.toThrow(
+          'Tool "risky_tool" requires user confirmation and cannot be used in a non-interactive subagent.',
+        );
+      });
+
+      it('should succeed if tools do not require confirmation', async () => {
+        const mockTool = {
+          schema: { parameters: { type: Type.OBJECT, properties: {} } },
+          build: vi.fn().mockReturnValue({
+            shouldConfirmExecute: vi.fn().mockResolvedValue(null),
+          }),
+        };
+        const { config } = await createMockConfig({
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          getTool: vi.fn().mockReturnValue(mockTool as any),
+        });
+
+        const toolConfig: ToolConfig = { tools: ['safe_tool'] };
+
+        const scope = await SubAgentScope.create(
+          'test-agent',
+          config,
+          promptConfig,
+          defaultModelConfig,
+          defaultRunConfig,
+          toolConfig,
+        );
+        expect(scope).toBeInstanceOf(SubAgentScope);
+      });
+
+      it('should skip interactivity check and warn for tools with required parameters', async () => {
+        const consoleWarnSpy = vi
+          .spyOn(console, 'warn')
+          .mockImplementation(() => {});
+
+        const mockToolWithParams = {
+          schema: {
+            parameters: {
+              type: Type.OBJECT,
+              properties: {
+                path: { type: Type.STRING },
+              },
+              required: ['path'],
+            },
+          },
+          // build should not be called, but we mock it to be safe
+          build: vi.fn(),
+        };
+
+        const { config } = await createMockConfig({
+          getTool: vi.fn().mockReturnValue(mockToolWithParams),
+        });
+
+        const toolConfig: ToolConfig = { tools: ['tool_with_params'] };
+
+        // The creation should succeed without throwing
+        const scope = await SubAgentScope.create(
+          'test-agent',
+          config,
+          promptConfig,
+          defaultModelConfig,
+          defaultRunConfig,
+          toolConfig,
+        );
+
+        expect(scope).toBeInstanceOf(SubAgentScope);
+
+        // Check that the warning was logged
+        expect(consoleWarnSpy).toHaveBeenCalledWith(
+          'Cannot check tool "tool_with_params" for interactivity because it requires parameters. Assuming it is safe for non-interactive use.',
+        );
+
+        // Ensure build was never called
+        expect(mockToolWithParams.build).not.toHaveBeenCalled();
+
+        consoleWarnSpy.mockRestore();
+      });
+    });
+
+    describe('runNonInteractive - Initialization and Prompting', () => {
+      it('should correctly template the system prompt and initialize GeminiChat', async () => {
+        const { config } = await createMockConfig();
+
+        vi.mocked(GeminiChat).mockClear();
+
+        const promptConfig: PromptConfig = {
+          systemPrompt: 'Hello ${name}, your task is ${task}.',
+        };
+        const context = new ContextState();
+        context.set('name', 'Agent');
+        context.set('task', 'Testing');
+
+        // Model stops immediately
+        mockSendMessageStream.mockImplementation(createMockStream(['stop']));
+
+        const scope = await SubAgentScope.create(
+          'test-agent',
+          config,
+          promptConfig,
+          defaultModelConfig,
+          defaultRunConfig,
+        );
+
+        await scope.runNonInteractive(context);
+
+        // Check if GeminiChat was initialized correctly by the subagent
+        expect(GeminiChat).toHaveBeenCalledTimes(1);
+        const callArgs = vi.mocked(GeminiChat).mock.calls[0];
+
+        // Check Generation Config
+        const generationConfig = getGenerationConfigFromMock();
+
+        // Check temperature override
+        expect(generationConfig.temperature).toBe(defaultModelConfig.temp);
+        expect(generationConfig.systemInstruction).toContain(
+          'Hello Agent, your task is Testing.',
+        );
+        expect(generationConfig.systemInstruction).toContain(
+          'Important Rules:',
+        );
+
+        // Check History (should include environment context)
+        const history = callArgs[3];
+        expect(history).toEqual([
+          { role: 'user', parts: [{ text: 'Env Context' }] },
+          {
+            role: 'model',
+            parts: [{ text: 'Got it. Thanks for the context!' }],
+          },
+        ]);
+      });
+
+      it('should include output instructions in the system prompt when outputs are defined', async () => {
+        const { config } = await createMockConfig();
+        vi.mocked(GeminiChat).mockClear();
+
+        const promptConfig: PromptConfig = { systemPrompt: 'Do the task.' };
+        const outputConfig: OutputConfig = {
+          outputs: {
+            result1: 'The first result',
+          },
+        };
+        const context = new ContextState();
+
+        // Model stops immediately
+        mockSendMessageStream.mockImplementation(createMockStream(['stop']));
+
+        const scope = await SubAgentScope.create(
+          'test-agent',
+          config,
+          promptConfig,
+          defaultModelConfig,
+          defaultRunConfig,
+          undefined, // ToolConfig
+          outputConfig,
+        );
+
+        await scope.runNonInteractive(context);
+
+        const generationConfig = getGenerationConfigFromMock();
+        const systemInstruction = generationConfig.systemInstruction as string;
+
+        expect(systemInstruction).toContain('Do the task.');
+        expect(systemInstruction).toContain(
+          'you MUST emit the required output variables',
+        );
+        expect(systemInstruction).toContain(
+          "Use 'self.emitvalue' to emit the 'result1' key",
+        );
+      });
+
+      it('should use initialMessages instead of systemPrompt if provided', async () => {
+        const { config } = await createMockConfig();
+        vi.mocked(GeminiChat).mockClear();
+
+        const initialMessages: Content[] = [
+          { role: 'user', parts: [{ text: 'Hi' }] },
+        ];
+        const promptConfig: PromptConfig = { initialMessages };
+        const context = new ContextState();
+
+        // Model stops immediately
+        mockSendMessageStream.mockImplementation(createMockStream(['stop']));
+
+        const scope = await SubAgentScope.create(
+          'test-agent',
+          config,
+          promptConfig,
+          defaultModelConfig,
+          defaultRunConfig,
+        );
+
+        await scope.runNonInteractive(context);
+
+        const callArgs = vi.mocked(GeminiChat).mock.calls[0];
+        const generationConfig = getGenerationConfigFromMock();
+        const history = callArgs[3];
+
+        expect(generationConfig.systemInstruction).toBeUndefined();
+        expect(history).toEqual([
+          { role: 'user', parts: [{ text: 'Env Context' }] },
+          {
+            role: 'model',
+            parts: [{ text: 'Got it. Thanks for the context!' }],
+          },
+          ...initialMessages,
+        ]);
+      });
+
+      it('should throw an error if template variables are missing', async () => {
+        const { config } = await createMockConfig();
+        const promptConfig: PromptConfig = {
+          systemPrompt: 'Hello ${name}, you are missing ${missing}.',
+        };
+        const context = new ContextState();
+        context.set('name', 'Agent');
+        // 'missing' is not set
+
+        const scope = await SubAgentScope.create(
+          'test-agent',
+          config,
+          promptConfig,
+          defaultModelConfig,
+          defaultRunConfig,
+        );
+
+        // The error from templating causes the runNonInteractive to reject and the terminate_reason to be ERROR.
+        await expect(scope.runNonInteractive(context)).rejects.toThrow(
+          'Missing context values for the following keys: missing',
+        );
+        expect(scope.output.terminate_reason).toBe(SubagentTerminateMode.ERROR);
+      });
+
+      it('should validate that systemPrompt and initialMessages are mutually exclusive', async () => {
+        const { config } = await createMockConfig();
+        const promptConfig: PromptConfig = {
+          systemPrompt: 'System',
+          initialMessages: [{ role: 'user', parts: [{ text: 'Hi' }] }],
+        };
+        const context = new ContextState();
+
+        const agent = await SubAgentScope.create(
+          'TestAgent',
+          config,
+          promptConfig,
+          defaultModelConfig,
+          defaultRunConfig,
+        );
+
+        await expect(agent.runNonInteractive(context)).rejects.toThrow(
+          'PromptConfig cannot have both `systemPrompt` and `initialMessages` defined.',
+        );
+        expect(agent.output.terminate_reason).toBe(SubagentTerminateMode.ERROR);
+      });
+    });
+
+    describe('runNonInteractive - Execution and Tool Use', () => {
+      const promptConfig: PromptConfig = { systemPrompt: 'Execute task.' };
+
+      it('should terminate with GOAL if no outputs are expected and model stops', async () => {
+        const { config } = await createMockConfig();
+        // Model stops immediately
+        mockSendMessageStream.mockImplementation(createMockStream(['stop']));
+
+        const scope = await SubAgentScope.create(
+          'test-agent',
+          config,
+          promptConfig,
+          defaultModelConfig,
+          defaultRunConfig,
+          // No ToolConfig, No OutputConfig
+        );
+
+        await scope.runNonInteractive(new ContextState());
+
+        expect(scope.output.terminate_reason).toBe(SubagentTerminateMode.GOAL);
+        expect(scope.output.emitted_vars).toEqual({});
+        expect(mockSendMessageStream).toHaveBeenCalledTimes(1);
+        // Check the initial message
+        expect(mockSendMessageStream.mock.calls[0][0].message).toEqual([
+          { text: 'Get Started!' },
+        ]);
+      });
+
+      it('should handle self.emitvalue and terminate with GOAL when outputs are met', async () => {
+        const { config } = await createMockConfig();
+        const outputConfig: OutputConfig = {
+          outputs: { result: 'The final result' },
+        };
+
+        // Turn 1: Model responds with emitvalue call
+        // Turn 2: Model stops after receiving the tool response
+        mockSendMessageStream.mockImplementation(
+          createMockStream([
+            [
+              {
+                name: 'self.emitvalue',
+                args: {
+                  emit_variable_name: 'result',
+                  emit_variable_value: 'Success!',
+                },
+              },
+            ],
+            'stop',
+          ]),
+        );
+
+        const scope = await SubAgentScope.create(
+          'test-agent',
+          config,
+          promptConfig,
+          defaultModelConfig,
+          defaultRunConfig,
+          undefined,
+          outputConfig,
+        );
+
+        await scope.runNonInteractive(new ContextState());
+
+        expect(scope.output.terminate_reason).toBe(SubagentTerminateMode.GOAL);
+        expect(scope.output.emitted_vars).toEqual({ result: 'Success!' });
+        expect(mockSendMessageStream).toHaveBeenCalledTimes(2);
+
+        // Check the tool response sent back in the second call
+        const secondCallArgs = mockSendMessageStream.mock.calls[1][0];
+        expect(secondCallArgs.message).toEqual([
+          { text: 'Emitted variable result successfully' },
+        ]);
+      });
+
+      it('should execute external tools and provide the response to the model', async () => {
+        const listFilesToolDef: FunctionDeclaration = {
+          name: 'list_files',
+          description: 'Lists files',
+          parameters: { type: Type.OBJECT, properties: {} },
+        };
+
+        const { config, toolRegistry } = await createMockConfig({
+          getFunctionDeclarationsFiltered: vi
+            .fn()
+            .mockReturnValue([listFilesToolDef]),
+        });
+        const toolConfig: ToolConfig = { tools: ['list_files'] };
+
+        // Turn 1: Model calls the external tool
+        // Turn 2: Model stops
+        mockSendMessageStream.mockImplementation(
+          createMockStream([
+            [
+              {
+                id: 'call_1',
+                name: 'list_files',
+                args: { path: '.' },
+              },
+            ],
+            'stop',
+          ]),
+        );
+
+        // Mock the tool execution result
+        vi.mocked(executeToolCall).mockResolvedValue({
+          callId: 'call_1',
+          responseParts: 'file1.txt\nfile2.ts',
+          resultDisplay: 'Listed 2 files',
+          error: undefined,
+          errorType: undefined, // Or ToolErrorType.NONE if available and appropriate
+        });
+
+        const scope = await SubAgentScope.create(
+          'test-agent',
+          config,
+          promptConfig,
+          defaultModelConfig,
+          defaultRunConfig,
+          toolConfig,
+        );
+
+        await scope.runNonInteractive(new ContextState());
+
+        // Check tool execution
+        expect(executeToolCall).toHaveBeenCalledWith(
+          config,
+          expect.objectContaining({ name: 'list_files', args: { path: '.' } }),
+          toolRegistry,
+          expect.any(AbortSignal),
+        );
+
+        // Check the response sent back to the model
+        const secondCallArgs = mockSendMessageStream.mock.calls[1][0];
+        expect(secondCallArgs.message).toEqual([
+          { text: 'file1.txt\nfile2.ts' },
+        ]);
+
+        expect(scope.output.terminate_reason).toBe(SubagentTerminateMode.GOAL);
+      });
+
+      it('should provide specific tool error responses to the model', async () => {
+        const { config } = await createMockConfig();
+        const toolConfig: ToolConfig = { tools: ['failing_tool'] };
+
+        // Turn 1: Model calls the failing tool
+        // Turn 2: Model stops after receiving the error response
+        mockSendMessageStream.mockImplementation(
+          createMockStream([
+            [
+              {
+                id: 'call_fail',
+                name: 'failing_tool',
+                args: {},
+              },
+            ],
+            'stop',
+          ]),
+        );
+
+        // Mock the tool execution failure.
+        vi.mocked(executeToolCall).mockResolvedValue({
+          callId: 'call_fail',
+          responseParts: 'ERROR: Tool failed catastrophically', // This should be sent to the model
+          resultDisplay: 'Tool failed catastrophically',
+          error: new Error('Failure'),
+          errorType: ToolErrorType.INVALID_TOOL_PARAMS,
+        });
+
+        const scope = await SubAgentScope.create(
+          'test-agent',
+          config,
+          promptConfig,
+          defaultModelConfig,
+          defaultRunConfig,
+          toolConfig,
+        );
+
+        await scope.runNonInteractive(new ContextState());
+
+        // The agent should send the specific error message from responseParts.
+        const secondCallArgs = mockSendMessageStream.mock.calls[1][0];
+
+        expect(secondCallArgs.message).toEqual([
+          {
+            text: 'ERROR: Tool failed catastrophically',
+          },
+        ]);
+      });
+
+      it('should nudge the model if it stops before emitting all required variables', async () => {
+        const { config } = await createMockConfig();
+        const outputConfig: OutputConfig = {
+          outputs: { required_var: 'Must be present' },
+        };
+
+        // Turn 1: Model stops prematurely
+        // Turn 2: Model responds to the nudge and emits the variable
+        // Turn 3: Model stops
+        mockSendMessageStream.mockImplementation(
+          createMockStream([
+            'stop',
+            [
+              {
+                name: 'self.emitvalue',
+                args: {
+                  emit_variable_name: 'required_var',
+                  emit_variable_value: 'Here it is',
+                },
+              },
+            ],
+            'stop',
+          ]),
+        );
+
+        const scope = await SubAgentScope.create(
+          'test-agent',
+          config,
+          promptConfig,
+          defaultModelConfig,
+          defaultRunConfig,
+          undefined,
+          outputConfig,
+        );
+
+        await scope.runNonInteractive(new ContextState());
+
+        // Check the nudge message sent in Turn 2
+        const secondCallArgs = mockSendMessageStream.mock.calls[1][0];
+
+        // We check that the message contains the required variable name and the nudge phrasing.
+        expect(secondCallArgs.message[0].text).toContain('required_var');
+        expect(secondCallArgs.message[0].text).toContain(
+          'You have stopped calling tools',
+        );
+
+        expect(scope.output.terminate_reason).toBe(SubagentTerminateMode.GOAL);
+        expect(scope.output.emitted_vars).toEqual({
+          required_var: 'Here it is',
+        });
+        expect(mockSendMessageStream).toHaveBeenCalledTimes(3);
+      });
+    });
+
+    describe('runNonInteractive - Termination and Recovery', () => {
+      const promptConfig: PromptConfig = { systemPrompt: 'Execute task.' };
+
+      it('should terminate with MAX_TURNS if the limit is reached', async () => {
+        const { config } = await createMockConfig();
+        const runConfig: RunConfig = { ...defaultRunConfig, max_turns: 2 };
+
+        // Model keeps looping by calling emitvalue repeatedly
+        mockSendMessageStream.mockImplementation(
+          createMockStream([
+            [
+              {
+                name: 'self.emitvalue',
+                args: { emit_variable_name: 'loop', emit_variable_value: 'v1' },
+              },
+            ],
+            [
+              {
+                name: 'self.emitvalue',
+                args: { emit_variable_name: 'loop', emit_variable_value: 'v2' },
+              },
+            ],
+            // This turn should not happen
+            [
+              {
+                name: 'self.emitvalue',
+                args: { emit_variable_name: 'loop', emit_variable_value: 'v3' },
+              },
+            ],
+          ]),
+        );
+
+        const scope = await SubAgentScope.create(
+          'test-agent',
+          config,
+          promptConfig,
+          defaultModelConfig,
+          runConfig,
+        );
+
+        await scope.runNonInteractive(new ContextState());
+
+        expect(mockSendMessageStream).toHaveBeenCalledTimes(2);
+        expect(scope.output.terminate_reason).toBe(
+          SubagentTerminateMode.MAX_TURNS,
+        );
+      });
+
+      it('should terminate with TIMEOUT if the time limit is reached during an LLM call', async () => {
+        // Use fake timers to reliably test timeouts
+        vi.useFakeTimers();
+
+        const { config } = await createMockConfig();
+        const runConfig: RunConfig = { max_time_minutes: 5, max_turns: 100 };
+
+        // We need to control the resolution of the sendMessageStream promise to advance the timer during execution.
+        let resolveStream: (
+          value: AsyncGenerator<unknown, void, unknown>,
+        ) => void;
+        const streamPromise = new Promise<
+          AsyncGenerator<unknown, void, unknown>
+        >((resolve) => {
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolveStream = resolve as any;
+        });
+
+        // The LLM call will hang until we resolve the promise.
+        mockSendMessageStream.mockReturnValue(streamPromise);
+
+        const scope = await SubAgentScope.create(
+          'test-agent',
+          config,
+          promptConfig,
+          defaultModelConfig,
+          runConfig,
+        );
+
+        const runPromise = scope.runNonInteractive(new ContextState());
+
+        // Advance time beyond the limit (6 minutes) while the agent is awaiting the LLM response.
+        await vi.advanceTimersByTimeAsync(6 * 60 * 1000);
+
+        // Now resolve the stream. The model returns 'stop'.
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        resolveStream!(createMockStream(['stop'])() as any);
+
+        await runPromise;
+
+        expect(scope.output.terminate_reason).toBe(
+          SubagentTerminateMode.TIMEOUT,
+        );
+        expect(mockSendMessageStream).toHaveBeenCalledTimes(1);
+
+        vi.useRealTimers();
+      });
+
+      it('should terminate with ERROR if the model call throws', async () => {
+        const { config } = await createMockConfig();
+        mockSendMessageStream.mockRejectedValue(new Error('API Failure'));
+
+        const scope = await SubAgentScope.create(
+          'test-agent',
+          config,
+          promptConfig,
+          defaultModelConfig,
+          defaultRunConfig,
+        );
+
+        await expect(
+          scope.runNonInteractive(new ContextState()),
+        ).rejects.toThrow('API Failure');
+        expect(scope.output.terminate_reason).toBe(SubagentTerminateMode.ERROR);
+      });
+    });
+  });
+});
diff --git a/packages/core/src/core/subagent.ts b/packages/core/src/core/subagent.ts
new file mode 100644
index 00000000..e11a5209
--- /dev/null
+++ b/packages/core/src/core/subagent.ts
@@ -0,0 +1,681 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { reportError } from '../utils/errorReporting.js';
+import { ToolRegistry } from '../tools/tool-registry.js';
+import { Config } from '../config/config.js';
+import { ToolCallRequestInfo } from './turn.js';
+import { executeToolCall } from './nonInteractiveToolExecutor.js';
+import { createContentGenerator } from './contentGenerator.js';
+import { getEnvironmentContext } from '../utils/environmentContext.js';
+import {
+  Content,
+  Part,
+  FunctionCall,
+  GenerateContentConfig,
+  FunctionDeclaration,
+  Type,
+} from '@google/genai';
+import { GeminiChat } from './geminiChat.js';
+
+/**
+ * @fileoverview Defines the configuration interfaces for a subagent.
+ *
+ * These interfaces specify the structure for defining the subagent's prompt,
+ * the model parameters, and the execution settings.
+ */
+
+/**
+ * Describes the possible termination modes for a subagent.
+ * This enum provides a clear indication of why a subagent's execution might have ended.
+ */
+export enum SubagentTerminateMode {
+  /**
+   * Indicates that the subagent's execution terminated due to an unrecoverable error.
+   */
+  ERROR = 'ERROR',
+  /**
+   * Indicates that the subagent's execution terminated because it exceeded the maximum allowed working time.
+   */
+  TIMEOUT = 'TIMEOUT',
+  /**
+   * Indicates that the subagent's execution successfully completed all its defined goals.
+   */
+  GOAL = 'GOAL',
+  /**
+   * Indicates that the subagent's execution terminated because it exceeded the maximum number of turns.
+   */
+  MAX_TURNS = 'MAX_TURNS',
+}
+
+/**
+ * Represents the output structure of a subagent's execution.
+ * This interface defines the data that a subagent will return upon completion,
+ * including any emitted variables and the reason for its termination.
+ */
+export interface OutputObject {
+  /**
+   * A record of key-value pairs representing variables emitted by the subagent
+   * during its execution. These variables can be used by the calling agent.
+   */
+  emitted_vars: Record<string, string>;
+  /**
+   * The reason for the subagent's termination, indicating whether it completed
+   * successfully, timed out, or encountered an error.
+   */
+  terminate_reason: SubagentTerminateMode;
+}
+
+/**
+ * Configures the initial prompt for the subagent.
+ */
+export interface PromptConfig {
+  /**
+   * A single system prompt string that defines the subagent's persona and instructions.
+   * Note: You should use either `systemPrompt` or `initialMessages`, but not both.
+   */
+  systemPrompt?: string;
+
+  /**
+   * An array of user/model content pairs to seed the chat history for few-shot prompting.
+   * Note: You should use either `systemPrompt` or `initialMessages`, but not both.
+   */
+  initialMessages?: Content[];
+}
+
+/**
+ * Configures the tools available to the subagent during its execution.
+ */
+export interface ToolConfig {
+  /**
+   * A list of tool names (from the tool registry) or full function declarations
+   * that the subagent is permitted to use.
+   */
+  tools: Array<string | FunctionDeclaration>;
+}
+
+/**
+ * Configures the expected outputs for the subagent.
+ */
+export interface OutputConfig {
+  /**
+   * A record describing the variables the subagent is expected to emit.
+   * The subagent will be prompted to generate these values before terminating.
+   */
+  outputs: Record<string, string>;
+}
+
+/**
+ * Configures the generative model parameters for the subagent.
+ * This interface specifies the model to be used and its associated generation settings,
+ * such as temperature and top-p values, which influence the creativity and diversity of the model's output.
+ */
+export interface ModelConfig {
+  /**
+   * The name or identifier of the model to be used (e.g., 'gemini-2.5-pro').
+   *
+   * TODO: In the future, this needs to support 'auto' or some other string to support routing use cases.
+   */
+  model: string;
+  /**
+   * The temperature for the model's sampling process.
+   */
+  temp: number;
+  /**
+   * The top-p value for nucleus sampling.
+   */
+  top_p: number;
+}
+
+/**
+ * Configures the execution environment and constraints for the subagent.
+ * This interface defines parameters that control the subagent's runtime behavior,
+ * such as maximum execution time, to prevent infinite loops or excessive resource consumption.
+ *
+ * TODO: Consider adding max_tokens as a form of budgeting.
+ */
+export interface RunConfig {
+  /** The maximum execution time for the subagent in minutes. */
+  max_time_minutes: number;
+  /**
+   * The maximum number of conversational turns (a user message + model response)
+   * before the execution is terminated. Helps prevent infinite loops.
+   */
+  max_turns?: number;
+}
+
+/**
+ * Manages the runtime context state for the subagent.
+ * This class provides a mechanism to store and retrieve key-value pairs
+ * that represent the dynamic state and variables accessible to the subagent
+ * during its execution.
+ */
+export class ContextState {
+  private state: Record<string, unknown> = {};
+
+  /**
+   * Retrieves a value from the context state.
+   *
+   * @param key - The key of the value to retrieve.
+   * @returns The value associated with the key, or undefined if the key is not found.
+   */
+  get(key: string): unknown {
+    return this.state[key];
+  }
+
+  /**
+   * Sets a value in the context state.
+   *
+   * @param key - The key to set the value under.
+   * @param value - The value to set.
+   */
+  set(key: string, value: unknown): void {
+    this.state[key] = value;
+  }
+
+  /**
+   * Retrieves all keys in the context state.
+   *
+   * @returns An array of all keys in the context state.
+   */
+  get_keys(): string[] {
+    return Object.keys(this.state);
+  }
+}
+
+/**
+ * Replaces `${...}` placeholders in a template string with values from a context.
+ *
+ * This function identifies all placeholders in the format `${key}`, validates that
+ * each key exists in the provided `ContextState`, and then performs the substitution.
+ *
+ * @param template The template string containing placeholders.
+ * @param context The `ContextState` object providing placeholder values.
+ * @returns The populated string with all placeholders replaced.
+ * @throws {Error} if any placeholder key is not found in the context.
+ */
+function templateString(template: string, context: ContextState): string {
+  const placeholderRegex = /\$\{(\w+)\}/g;
+
+  // First, find all unique keys required by the template.
+  const requiredKeys = new Set(
+    Array.from(template.matchAll(placeholderRegex), (match) => match[1]),
+  );
+
+  // Check if all required keys exist in the context.
+  const contextKeys = new Set(context.get_keys());
+  const missingKeys = Array.from(requiredKeys).filter(
+    (key) => !contextKeys.has(key),
+  );
+
+  if (missingKeys.length > 0) {
+    throw new Error(
+      `Missing context values for the following keys: ${missingKeys.join(
+        ', ',
+      )}`,
+    );
+  }
+
+  // Perform the replacement using a replacer function.
+  return template.replace(placeholderRegex, (_match, key) =>
+    String(context.get(key)),
+  );
+}
+
+/**
+ * Represents the scope and execution environment for a subagent.
+ * This class orchestrates the subagent's lifecycle, managing its chat interactions,
+ * runtime context, and the collection of its outputs.
+ */
+export class SubAgentScope {
+  output: OutputObject = {
+    terminate_reason: SubagentTerminateMode.ERROR,
+    emitted_vars: {},
+  };
+  private readonly subagentId: string;
+
+  /**
+   * Constructs a new SubAgentScope instance.
+   * @param name - The name for the subagent, used for logging and identification.
+   * @param runtimeContext - The shared runtime configuration and services.
+   * @param promptConfig - Configuration for the subagent's prompt and behavior.
+   * @param modelConfig - Configuration for the generative model parameters.
+   * @param runConfig - Configuration for the subagent's execution environment.
+   * @param toolConfig - Optional configuration for tools available to the subagent.
+   * @param outputConfig - Optional configuration for the subagent's expected outputs.
+   */
+  private constructor(
+    readonly name: string,
+    readonly runtimeContext: Config,
+    private readonly promptConfig: PromptConfig,
+    private readonly modelConfig: ModelConfig,
+    private readonly runConfig: RunConfig,
+    private readonly toolConfig?: ToolConfig,
+    private readonly outputConfig?: OutputConfig,
+  ) {
+    const randomPart = Math.random().toString(36).slice(2, 8);
+    this.subagentId = `${this.name}-${randomPart}`;
+  }
+
+  /**
+   * Creates and validates a new SubAgentScope instance.
+   * This factory method ensures that all tools provided in the prompt configuration
+   * are valid for non-interactive use before creating the subagent instance.
+   * @param {string} name - The name of the subagent.
+   * @param {Config} runtimeContext - The shared runtime configuration and services.
+   * @param {PromptConfig} promptConfig - Configuration for the subagent's prompt and behavior.
+   * @param {ModelConfig} modelConfig - Configuration for the generative model parameters.
+   * @param {RunConfig} runConfig - Configuration for the subagent's execution environment.
+   * @param {ToolConfig} [toolConfig] - Optional configuration for tools.
+   * @param {OutputConfig} [outputConfig] - Optional configuration for expected outputs.
+   * @returns {Promise<SubAgentScope>} A promise that resolves to a valid SubAgentScope instance.
+   * @throws {Error} If any tool requires user confirmation.
+   */
+  static async create(
+    name: string,
+    runtimeContext: Config,
+    promptConfig: PromptConfig,
+    modelConfig: ModelConfig,
+    runConfig: RunConfig,
+    toolConfig?: ToolConfig,
+    outputConfig?: OutputConfig,
+  ): Promise<SubAgentScope> {
+    if (toolConfig) {
+      const toolRegistry: ToolRegistry = await runtimeContext.getToolRegistry();
+      const toolsToLoad: string[] = [];
+      for (const tool of toolConfig.tools) {
+        if (typeof tool === 'string') {
+          toolsToLoad.push(tool);
+        }
+      }
+
+      for (const toolName of toolsToLoad) {
+        const tool = toolRegistry.getTool(toolName);
+        if (tool) {
+          const requiredParams = tool.schema.parameters?.required ?? [];
+          if (requiredParams.length > 0) {
+            // This check is imperfect. A tool might require parameters but still
+            // be interactive (e.g., `delete_file(path)`). However, we cannot
+            // build a generic invocation without knowing what dummy parameters
+            // to provide. Crashing here because `build({})` fails is worse
+            // than allowing a potential hang later if an interactive tool is
+            // used. This is a best-effort check.
+            console.warn(
+              `Cannot check tool "${toolName}" for interactivity because it requires parameters. Assuming it is safe for non-interactive use.`,
+            );
+            continue;
+          }
+
+          const invocation = tool.build({});
+          const confirmationDetails = await invocation.shouldConfirmExecute(
+            new AbortController().signal,
+          );
+          if (confirmationDetails) {
+            throw new Error(
+              `Tool "${toolName}" requires user confirmation and cannot be used in a non-interactive subagent.`,
+            );
+          }
+        }
+      }
+    }
+
+    return new SubAgentScope(
+      name,
+      runtimeContext,
+      promptConfig,
+      modelConfig,
+      runConfig,
+      toolConfig,
+      outputConfig,
+    );
+  }
+
+  /**
+   * Runs the subagent in a non-interactive mode.
+   * This method orchestrates the subagent's execution loop, including prompt templating,
+   * tool execution, and termination conditions.
+   * @param {ContextState} context - The current context state containing variables for prompt templating.
+   * @returns {Promise<void>} A promise that resolves when the subagent has completed its execution.
+   */
+  async runNonInteractive(context: ContextState): Promise<void> {
+    const chat = await this.createChatObject(context);
+
+    if (!chat) {
+      this.output.terminate_reason = SubagentTerminateMode.ERROR;
+      return;
+    }
+
+    const abortController = new AbortController();
+    const toolRegistry: ToolRegistry =
+      await this.runtimeContext.getToolRegistry();
+
+    // Prepare the list of tools available to the subagent.
+    const toolsList: FunctionDeclaration[] = [];
+    if (this.toolConfig) {
+      const toolsToLoad: string[] = [];
+      for (const tool of this.toolConfig.tools) {
+        if (typeof tool === 'string') {
+          toolsToLoad.push(tool);
+        } else {
+          toolsList.push(tool);
+        }
+      }
+      toolsList.push(
+        ...toolRegistry.getFunctionDeclarationsFiltered(toolsToLoad),
+      );
+    }
+    // Add local scope functions if outputs are expected.
+    if (this.outputConfig && this.outputConfig.outputs) {
+      toolsList.push(...this.getScopeLocalFuncDefs());
+    }
+
+    let currentMessages: Content[] = [
+      { role: 'user', parts: [{ text: 'Get Started!' }] },
+    ];
+
+    const startTime = Date.now();
+    let turnCounter = 0;
+    try {
+      while (true) {
+        // Check termination conditions.
+        if (
+          this.runConfig.max_turns &&
+          turnCounter >= this.runConfig.max_turns
+        ) {
+          this.output.terminate_reason = SubagentTerminateMode.MAX_TURNS;
+          break;
+        }
+        let durationMin = (Date.now() - startTime) / (1000 * 60);
+        if (durationMin >= this.runConfig.max_time_minutes) {
+          this.output.terminate_reason = SubagentTerminateMode.TIMEOUT;
+          break;
+        }
+
+        const promptId = `${this.runtimeContext.getSessionId()}#${this.subagentId}#${turnCounter++}`;
+        const messageParams = {
+          message: currentMessages[0]?.parts || [],
+          config: {
+            abortSignal: abortController.signal,
+            tools: [{ functionDeclarations: toolsList }],
+          },
+        };
+
+        const responseStream = await chat.sendMessageStream(
+          messageParams,
+          promptId,
+        );
+
+        const functionCalls: FunctionCall[] = [];
+        for await (const resp of responseStream) {
+          if (abortController.signal.aborted) return;
+          if (resp.functionCalls) functionCalls.push(...resp.functionCalls);
+        }
+
+        durationMin = (Date.now() - startTime) / (1000 * 60);
+        if (durationMin >= this.runConfig.max_time_minutes) {
+          this.output.terminate_reason = SubagentTerminateMode.TIMEOUT;
+          break;
+        }
+
+        if (functionCalls.length > 0) {
+          currentMessages = await this.processFunctionCalls(
+            functionCalls,
+            toolRegistry,
+            abortController,
+            promptId,
+          );
+        } else {
+          // Model stopped calling tools. Check if goal is met.
+          if (
+            !this.outputConfig ||
+            Object.keys(this.outputConfig.outputs).length === 0
+          ) {
+            this.output.terminate_reason = SubagentTerminateMode.GOAL;
+            break;
+          }
+
+          const remainingVars = Object.keys(this.outputConfig.outputs).filter(
+            (key) => !(key in this.output.emitted_vars),
+          );
+
+          if (remainingVars.length === 0) {
+            this.output.terminate_reason = SubagentTerminateMode.GOAL;
+            break;
+          }
+
+          const nudgeMessage = `You have stopped calling tools but have not emitted the following required variables: ${remainingVars.join(
+            ', ',
+          )}. Please use the 'self.emitvalue' tool to emit them now, or continue working if necessary.`;
+
+          console.debug(nudgeMessage);
+
+          currentMessages = [
+            {
+              role: 'user',
+              parts: [{ text: nudgeMessage }],
+            },
+          ];
+        }
+      }
+    } catch (error) {
+      console.error('Error during subagent execution:', error);
+      this.output.terminate_reason = SubagentTerminateMode.ERROR;
+      throw error;
+    }
+  }
+
+  /**
+   * Processes a list of function calls, executing each one and collecting their responses.
+   * This method iterates through the provided function calls, executes them using the
+   * `executeToolCall` function (or handles `self.emitvalue` internally), and aggregates
+   * their results. It also manages error reporting for failed tool executions.
+   * @param {FunctionCall[]} functionCalls - An array of `FunctionCall` objects to process.
+   * @param {ToolRegistry} toolRegistry - The tool registry to look up and execute tools.
+   * @param {AbortController} abortController - An `AbortController` to signal cancellation of tool executions.
+   * @returns {Promise<Content[]>} A promise that resolves to an array of `Content` parts representing the tool responses,
+   *          which are then used to update the chat history.
+   */
+  private async processFunctionCalls(
+    functionCalls: FunctionCall[],
+    toolRegistry: ToolRegistry,
+    abortController: AbortController,
+    promptId: string,
+  ): Promise<Content[]> {
+    const toolResponseParts: Part[] = [];
+
+    for (const functionCall of functionCalls) {
+      const callId = functionCall.id ?? `${functionCall.name}-${Date.now()}`;
+      const requestInfo: ToolCallRequestInfo = {
+        callId,
+        name: functionCall.name as string,
+        args: (functionCall.args ?? {}) as Record<string, unknown>,
+        isClientInitiated: true,
+        prompt_id: promptId,
+      };
+
+      let toolResponse;
+
+      // Handle scope-local tools first.
+      if (functionCall.name === 'self.emitvalue') {
+        const valName = String(requestInfo.args['emit_variable_name']);
+        const valVal = String(requestInfo.args['emit_variable_value']);
+        this.output.emitted_vars[valName] = valVal;
+
+        toolResponse = {
+          callId,
+          responseParts: `Emitted variable ${valName} successfully`,
+          resultDisplay: `Emitted variable ${valName} successfully`,
+          error: undefined,
+        };
+      } else {
+        toolResponse = await executeToolCall(
+          this.runtimeContext,
+          requestInfo,
+          toolRegistry,
+          abortController.signal,
+        );
+      }
+
+      if (toolResponse.error) {
+        console.error(
+          `Error executing tool ${functionCall.name}: ${toolResponse.resultDisplay || toolResponse.error.message}`,
+        );
+      }
+
+      if (toolResponse.responseParts) {
+        const parts = Array.isArray(toolResponse.responseParts)
+          ? toolResponse.responseParts
+          : [toolResponse.responseParts];
+        for (const part of parts) {
+          if (typeof part === 'string') {
+            toolResponseParts.push({ text: part });
+          } else if (part) {
+            toolResponseParts.push(part);
+          }
+        }
+      }
+    }
+    // If all tool calls failed, inform the model so it can re-evaluate.
+    if (functionCalls.length > 0 && toolResponseParts.length === 0) {
+      toolResponseParts.push({
+        text: 'All tool calls failed. Please analyze the errors and try an alternative approach.',
+      });
+    }
+
+    return [{ role: 'user', parts: toolResponseParts }];
+  }
+
+  private async createChatObject(context: ContextState) {
+    if (!this.promptConfig.systemPrompt && !this.promptConfig.initialMessages) {
+      throw new Error(
+        'PromptConfig must have either `systemPrompt` or `initialMessages` defined.',
+      );
+    }
+    if (this.promptConfig.systemPrompt && this.promptConfig.initialMessages) {
+      throw new Error(
+        'PromptConfig cannot have both `systemPrompt` and `initialMessages` defined.',
+      );
+    }
+
+    const envParts = await getEnvironmentContext(this.runtimeContext);
+    const envHistory: Content[] = [
+      { role: 'user', parts: envParts },
+      { role: 'model', parts: [{ text: 'Got it. Thanks for the context!' }] },
+    ];
+
+    const start_history = [
+      ...envHistory,
+      ...(this.promptConfig.initialMessages ?? []),
+    ];
+
+    const systemInstruction = this.promptConfig.systemPrompt
+      ? this.buildChatSystemPrompt(context)
+      : undefined;
+
+    try {
+      const generationConfig: GenerateContentConfig & {
+        systemInstruction?: string | Content;
+      } = {
+        temperature: this.modelConfig.temp,
+        topP: this.modelConfig.top_p,
+      };
+
+      if (systemInstruction) {
+        generationConfig.systemInstruction = systemInstruction;
+      }
+
+      const contentGenerator = await createContentGenerator(
+        this.runtimeContext.getContentGeneratorConfig(),
+        this.runtimeContext,
+        this.runtimeContext.getSessionId(),
+      );
+
+      this.runtimeContext.setModel(this.modelConfig.model);
+
+      return new GeminiChat(
+        this.runtimeContext,
+        contentGenerator,
+        generationConfig,
+        start_history,
+      );
+    } catch (error) {
+      await reportError(
+        error,
+        'Error initializing Gemini chat session.',
+        start_history,
+        'startChat',
+      );
+      // The calling function will handle the undefined return.
+      return undefined;
+    }
+  }
+
+  /**
+   * Returns an array of FunctionDeclaration objects for tools that are local to the subagent's scope.
+   * Currently, this includes the `self.emitvalue` tool for emitting variables.
+   * @returns An array of `FunctionDeclaration` objects.
+   */
+  private getScopeLocalFuncDefs() {
+    const emitValueTool: FunctionDeclaration = {
+      name: 'self.emitvalue',
+      description: `* This tool emits A SINGLE return value from this execution, such that it can be collected and presented to the calling function.
+        * You can only emit ONE VALUE each time you call this tool. You are expected to call this tool MULTIPLE TIMES if you have MULTIPLE OUTPUTS.`,
+      parameters: {
+        type: Type.OBJECT,
+        properties: {
+          emit_variable_name: {
+            description: 'This is the name of the variable to be returned.',
+            type: Type.STRING,
+          },
+          emit_variable_value: {
+            description:
+              'This is the _value_ to be returned for this variable.',
+            type: Type.STRING,
+          },
+        },
+        required: ['emit_variable_name', 'emit_variable_value'],
+      },
+    };
+
+    return [emitValueTool];
+  }
+
+  /**
+   * Builds the system prompt for the chat based on the provided configurations.
+   * It templates the base system prompt and appends instructions for emitting
+   * variables if an `OutputConfig` is provided.
+   * @param {ContextState} context - The context for templating.
+   * @returns {string} The complete system prompt.
+   */
+  private buildChatSystemPrompt(context: ContextState): string {
+    if (!this.promptConfig.systemPrompt) {
+      // This should ideally be caught in createChatObject, but serves as a safeguard.
+      return '';
+    }
+
+    let finalPrompt = templateString(this.promptConfig.systemPrompt, context);
+
+    // Add instructions for emitting variables if needed.
+    if (this.outputConfig && this.outputConfig.outputs) {
+      let outputInstructions =
+        '\n\nAfter you have achieved all other goals, you MUST emit the required output variables. For each expected output, make one final call to the `self.emitvalue` tool.';
+
+      for (const [key, value] of Object.entries(this.outputConfig.outputs)) {
+        outputInstructions += `\n* Use 'self.emitvalue' to emit the '${key}' key, with a value described as: '${value}'`;
+      }
+      finalPrompt += outputInstructions;
+    }
+
+    // Add general non-interactive instructions.
+    finalPrompt += `
+
+Important Rules:
+ * You are running in a non-interactive mode. You CANNOT ask the user for input or clarification. You must proceed with the information you have.
+ * Once you believe all goals have been met and all required outputs have been emitted, stop calling tools.`;
+
+    return finalPrompt;
+  }
+}
diff --git a/packages/core/src/tools/tool-registry.ts b/packages/core/src/tools/tool-registry.ts
index 73b427d4..c77fab8c 100644
--- a/packages/core/src/tools/tool-registry.ts
+++ b/packages/core/src/tools/tool-registry.ts
@@ -365,6 +365,22 @@ export class ToolRegistry {
     return declarations;
   }
 
+  /**
+   * Retrieves a filtered list of tool schemas based on a list of tool names.
+   * @param toolNames - An array of tool names to include.
+   * @returns An array of FunctionDeclarations for the specified tools.
+   */
+  getFunctionDeclarationsFiltered(toolNames: string[]): FunctionDeclaration[] {
+    const declarations: FunctionDeclaration[] = [];
+    for (const name of toolNames) {
+      const tool = this.tools.get(name);
+      if (tool) {
+        declarations.push(tool.schema);
+      }
+    }
+    return declarations;
+  }
+
   /**
    * Returns an array of all registered and discovered tool instances.
    */
diff --git a/packages/core/src/utils/environmentContext.test.ts b/packages/core/src/utils/environmentContext.test.ts
new file mode 100644
index 00000000..656fb63f
--- /dev/null
+++ b/packages/core/src/utils/environmentContext.test.ts
@@ -0,0 +1,205 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import {
+  describe,
+  it,
+  expect,
+  vi,
+  beforeEach,
+  afterEach,
+  type Mock,
+} from 'vitest';
+import {
+  getEnvironmentContext,
+  getDirectoryContextString,
+} from './environmentContext.js';
+import { Config } from '../config/config.js';
+import { getFolderStructure } from './getFolderStructure.js';
+
+vi.mock('../config/config.js');
+vi.mock('./getFolderStructure.js', () => ({
+  getFolderStructure: vi.fn(),
+}));
+vi.mock('../tools/read-many-files.js');
+
+describe('getDirectoryContextString', () => {
+  let mockConfig: Partial<Config>;
+
+  beforeEach(() => {
+    mockConfig = {
+      getWorkspaceContext: vi.fn().mockReturnValue({
+        getDirectories: vi.fn().mockReturnValue(['/test/dir']),
+      }),
+      getFileService: vi.fn(),
+    };
+    vi.mocked(getFolderStructure).mockResolvedValue('Mock Folder Structure');
+  });
+
+  afterEach(() => {
+    vi.resetAllMocks();
+  });
+
+  it('should return context string for a single directory', async () => {
+    const contextString = await getDirectoryContextString(mockConfig as Config);
+    expect(contextString).toContain(
+      "I'm currently working in the directory: /test/dir",
+    );
+    expect(contextString).toContain(
+      'Here is the folder structure of the current working directories:\n\nMock Folder Structure',
+    );
+  });
+
+  it('should return context string for multiple directories', async () => {
+    (
+      vi.mocked(mockConfig.getWorkspaceContext!)().getDirectories as Mock
+    ).mockReturnValue(['/test/dir1', '/test/dir2']);
+    vi.mocked(getFolderStructure)
+      .mockResolvedValueOnce('Structure 1')
+      .mockResolvedValueOnce('Structure 2');
+
+    const contextString = await getDirectoryContextString(mockConfig as Config);
+    expect(contextString).toContain(
+      "I'm currently working in the following directories:\n  - /test/dir1\n  - /test/dir2",
+    );
+    expect(contextString).toContain(
+      'Here is the folder structure of the current working directories:\n\nStructure 1\nStructure 2',
+    );
+  });
+});
+
+describe('getEnvironmentContext', () => {
+  let mockConfig: Partial<Config>;
+  let mockToolRegistry: { getTool: Mock };
+
+  beforeEach(() => {
+    vi.useFakeTimers();
+    vi.setSystemTime(new Date('2025-08-05T12:00:00Z'));
+
+    mockToolRegistry = {
+      getTool: vi.fn(),
+    };
+
+    mockConfig = {
+      getWorkspaceContext: vi.fn().mockReturnValue({
+        getDirectories: vi.fn().mockReturnValue(['/test/dir']),
+      }),
+      getFileService: vi.fn(),
+      getFullContext: vi.fn().mockReturnValue(false),
+      getToolRegistry: vi.fn().mockResolvedValue(mockToolRegistry),
+    };
+
+    vi.mocked(getFolderStructure).mockResolvedValue('Mock Folder Structure');
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+    vi.resetAllMocks();
+  });
+
+  it('should return basic environment context for a single directory', async () => {
+    const parts = await getEnvironmentContext(mockConfig as Config);
+
+    expect(parts.length).toBe(1);
+    const context = parts[0].text;
+
+    expect(context).toContain("Today's date is Tuesday, August 5, 2025");
+    expect(context).toContain(`My operating system is: ${process.platform}`);
+    expect(context).toContain(
+      "I'm currently working in the directory: /test/dir",
+    );
+    expect(context).toContain(
+      'Here is the folder structure of the current working directories:\n\nMock Folder Structure',
+    );
+    expect(getFolderStructure).toHaveBeenCalledWith('/test/dir', {
+      fileService: undefined,
+    });
+  });
+
+  it('should return basic environment context for multiple directories', async () => {
+    (
+      vi.mocked(mockConfig.getWorkspaceContext!)().getDirectories as Mock
+    ).mockReturnValue(['/test/dir1', '/test/dir2']);
+    vi.mocked(getFolderStructure)
+      .mockResolvedValueOnce('Structure 1')
+      .mockResolvedValueOnce('Structure 2');
+
+    const parts = await getEnvironmentContext(mockConfig as Config);
+
+    expect(parts.length).toBe(1);
+    const context = parts[0].text;
+
+    expect(context).toContain(
+      "I'm currently working in the following directories:\n  - /test/dir1\n  - /test/dir2",
+    );
+    expect(context).toContain(
+      'Here is the folder structure of the current working directories:\n\nStructure 1\nStructure 2',
+    );
+    expect(getFolderStructure).toHaveBeenCalledTimes(2);
+  });
+
+  it('should include full file context when getFullContext is true', async () => {
+    mockConfig.getFullContext = vi.fn().mockReturnValue(true);
+    const mockReadManyFilesTool = {
+      build: vi.fn().mockReturnValue({
+        execute: vi
+          .fn()
+          .mockResolvedValue({ llmContent: 'Full file content here' }),
+      }),
+    };
+    mockToolRegistry.getTool.mockReturnValue(mockReadManyFilesTool);
+
+    const parts = await getEnvironmentContext(mockConfig as Config);
+
+    expect(parts.length).toBe(2);
+    expect(parts[1].text).toBe(
+      '\n--- Full File Context ---\nFull file content here',
+    );
+    expect(mockToolRegistry.getTool).toHaveBeenCalledWith('read_many_files');
+    expect(mockReadManyFilesTool.build).toHaveBeenCalledWith({
+      paths: ['**/*'],
+      useDefaultExcludes: true,
+    });
+  });
+
+  it('should handle read_many_files returning no content', async () => {
+    mockConfig.getFullContext = vi.fn().mockReturnValue(true);
+    const mockReadManyFilesTool = {
+      build: vi.fn().mockReturnValue({
+        execute: vi.fn().mockResolvedValue({ llmContent: '' }),
+      }),
+    };
+    mockToolRegistry.getTool.mockReturnValue(mockReadManyFilesTool);
+
+    const parts = await getEnvironmentContext(mockConfig as Config);
+
+    expect(parts.length).toBe(1); // No extra part added
+  });
+
+  it('should handle read_many_files tool not being found', async () => {
+    mockConfig.getFullContext = vi.fn().mockReturnValue(true);
+    mockToolRegistry.getTool.mockReturnValue(null);
+
+    const parts = await getEnvironmentContext(mockConfig as Config);
+
+    expect(parts.length).toBe(1); // No extra part added
+  });
+
+  it('should handle errors when reading full file context', async () => {
+    mockConfig.getFullContext = vi.fn().mockReturnValue(true);
+    const mockReadManyFilesTool = {
+      build: vi.fn().mockReturnValue({
+        execute: vi.fn().mockRejectedValue(new Error('Read error')),
+      }),
+    };
+    mockToolRegistry.getTool.mockReturnValue(mockReadManyFilesTool);
+
+    const parts = await getEnvironmentContext(mockConfig as Config);
+
+    expect(parts.length).toBe(2);
+    expect(parts[1].text).toBe('\n--- Error reading full file context ---');
+  });
+});
diff --git a/packages/core/src/utils/environmentContext.ts b/packages/core/src/utils/environmentContext.ts
new file mode 100644
index 00000000..79fb6049
--- /dev/null
+++ b/packages/core/src/utils/environmentContext.ts
@@ -0,0 +1,109 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { Part } from '@google/genai';
+import { Config } from '../config/config.js';
+import { getFolderStructure } from './getFolderStructure.js';
+
+/**
+ * Generates a string describing the current workspace directories and their structures.
+ * @param {Config} config - The runtime configuration and services.
+ * @returns {Promise<string>} A promise that resolves to the directory context string.
+ */
+export async function getDirectoryContextString(
+  config: Config,
+): Promise<string> {
+  const workspaceContext = config.getWorkspaceContext();
+  const workspaceDirectories = workspaceContext.getDirectories();
+
+  const folderStructures = await Promise.all(
+    workspaceDirectories.map((dir) =>
+      getFolderStructure(dir, {
+        fileService: config.getFileService(),
+      }),
+    ),
+  );
+
+  const folderStructure = folderStructures.join('\n');
+
+  let workingDirPreamble: string;
+  if (workspaceDirectories.length === 1) {
+    workingDirPreamble = `I'm currently working in the directory: ${workspaceDirectories[0]}`;
+  } else {
+    const dirList = workspaceDirectories.map((dir) => `  - ${dir}`).join('\n');
+    workingDirPreamble = `I'm currently working in the following directories:\n${dirList}`;
+  }
+
+  return `${workingDirPreamble}
+Here is the folder structure of the current working directories:
+
+${folderStructure}`;
+}
+
+/**
+ * Retrieves environment-related information to be included in the chat context.
+ * This includes the current working directory, date, operating system, and folder structure.
+ * Optionally, it can also include the full file context if enabled.
+ * @param {Config} config - The runtime configuration and services.
+ * @returns A promise that resolves to an array of `Part` objects containing environment information.
+ */
+export async function getEnvironmentContext(config: Config): Promise<Part[]> {
+  const today = new Date().toLocaleDateString(undefined, {
+    weekday: 'long',
+    year: 'numeric',
+    month: 'long',
+    day: 'numeric',
+  });
+  const platform = process.platform;
+  const directoryContext = await getDirectoryContextString(config);
+
+  const context = `
+This is the Gemini CLI. We are setting up the context for our chat.
+Today's date is ${today}.
+My operating system is: ${platform}
+${directoryContext}
+        `.trim();
+
+  const initialParts: Part[] = [{ text: context }];
+  const toolRegistry = await config.getToolRegistry();
+
+  // Add full file context if the flag is set
+  if (config.getFullContext()) {
+    try {
+      const readManyFilesTool = toolRegistry.getTool('read_many_files');
+      if (readManyFilesTool) {
+        const invocation = readManyFilesTool.build({
+          paths: ['**/*'], // Read everything recursively
+          useDefaultExcludes: true, // Use default excludes
+        });
+
+        // Read all files in the target directory
+        const result = await invocation.execute(AbortSignal.timeout(30000));
+        if (result.llmContent) {
+          initialParts.push({
+            text: `\n--- Full File Context ---\n${result.llmContent}`,
+          });
+        } else {
+          console.warn(
+            'Full context requested, but read_many_files returned no content.',
+          );
+        }
+      } else {
+        console.warn(
+          'Full context requested, but read_many_files tool not found.',
+        );
+      }
+    } catch (error) {
+      // Not using reportError here as it's a startup/config phase, not a chat/generation phase error.
+      console.error('Error reading full file context:', error);
+      initialParts.push({
+        text: '\n--- Error reading full file context ---',
+      });
+    }
+  }
+
+  return initialParts;
+}

From 6ae75c9f32a968efa50857a8f24b958a58a84fd6 Mon Sep 17 00:00:00 2001
From: Jacob MacDonald <jakemac@google.com>
Date: Thu, 7 Aug 2025 07:34:40 -0700
Subject: [PATCH 033/107] Add a context percentage threshold setting for auto
 compression (#5721)

---
 docs/cli/configuration.md                |  12 +++
 packages/cli/src/config/config.test.ts   |  39 ++++++++
 packages/cli/src/config/config.ts        |   1 +
 packages/cli/src/config/settings.test.ts | 118 +++++++++++++++++++++++
 packages/cli/src/config/settings.ts      |  21 ++++
 packages/core/src/config/config.ts       |  11 +++
 packages/core/src/core/client.test.ts    |  10 +-
 packages/core/src/core/client.ts         |  14 ++-
 8 files changed, 219 insertions(+), 7 deletions(-)

diff --git a/docs/cli/configuration.md b/docs/cli/configuration.md
index 5c917a3f..9fc74adb 100644
--- a/docs/cli/configuration.md
+++ b/docs/cli/configuration.md
@@ -268,6 +268,18 @@ In addition to a project settings file, a project's `.gemini` directory can cont
     "loadMemoryFromIncludeDirectories": true
     ```
 
+- **`chatCompression`** (object):
+  - **Description:** Controls the settings for chat history compression, both automatic and
+    when manually invoked through the /compress command.
+  - **Properties:**
+    - **`contextPercentageThreshold`** (number): A value between 0 and 1 that specifies the token threshold for compression as a percentage of the model's total token limit. For example, a value of `0.6` will trigger compression when the chat history exceeds 60% of the token limit.
+  - **Example:**
+    ```json
+    "chatCompression": {
+      "contextPercentageThreshold": 0.6
+    }
+    ```
+
 ### Example `settings.json`:
 
 ```json
diff --git a/packages/cli/src/config/config.test.ts b/packages/cli/src/config/config.test.ts
index 6a7e3b57..b670fbc8 100644
--- a/packages/cli/src/config/config.test.ts
+++ b/packages/cli/src/config/config.test.ts
@@ -1123,3 +1123,42 @@ describe('loadCliConfig with includeDirectories', () => {
     );
   });
 });
+
+describe('loadCliConfig chatCompression', () => {
+  const originalArgv = process.argv;
+  const originalEnv = { ...process.env };
+
+  beforeEach(() => {
+    vi.resetAllMocks();
+    vi.mocked(os.homedir).mockReturnValue('/mock/home/user');
+    process.env.GEMINI_API_KEY = 'test-api-key';
+  });
+
+  afterEach(() => {
+    process.argv = originalArgv;
+    process.env = originalEnv;
+    vi.restoreAllMocks();
+  });
+
+  it('should pass chatCompression settings to the core config', async () => {
+    process.argv = ['node', 'script.js'];
+    const argv = await parseArguments();
+    const settings: Settings = {
+      chatCompression: {
+        contextPercentageThreshold: 0.5,
+      },
+    };
+    const config = await loadCliConfig(settings, [], 'test-session', argv);
+    expect(config.getChatCompression()).toEqual({
+      contextPercentageThreshold: 0.5,
+    });
+  });
+
+  it('should have undefined chatCompression if not in settings', async () => {
+    process.argv = ['node', 'script.js'];
+    const argv = await parseArguments();
+    const settings: Settings = {};
+    const config = await loadCliConfig(settings, [], 'test-session', argv);
+    expect(config.getChatCompression()).toBeUndefined();
+  });
+});
diff --git a/packages/cli/src/config/config.ts b/packages/cli/src/config/config.ts
index 2c942c08..a47d8301 100644
--- a/packages/cli/src/config/config.ts
+++ b/packages/cli/src/config/config.ts
@@ -482,6 +482,7 @@ export async function loadCliConfig(
     summarizeToolOutput: settings.summarizeToolOutput,
     ideMode,
     ideModeFeature,
+    chatCompression: settings.chatCompression,
     folderTrustFeature,
   });
 }
diff --git a/packages/cli/src/config/settings.test.ts b/packages/cli/src/config/settings.test.ts
index d0266720..f68b13e3 100644
--- a/packages/cli/src/config/settings.test.ts
+++ b/packages/cli/src/config/settings.test.ts
@@ -113,6 +113,7 @@ describe('Settings Loading and Merging', () => {
         customThemes: {},
         mcpServers: {},
         includeDirectories: [],
+        chatCompression: {},
       });
       expect(settings.errors.length).toBe(0);
     });
@@ -147,6 +148,7 @@ describe('Settings Loading and Merging', () => {
         customThemes: {},
         mcpServers: {},
         includeDirectories: [],
+        chatCompression: {},
       });
     });
 
@@ -181,6 +183,7 @@ describe('Settings Loading and Merging', () => {
         customThemes: {},
         mcpServers: {},
         includeDirectories: [],
+        chatCompression: {},
       });
     });
 
@@ -213,6 +216,7 @@ describe('Settings Loading and Merging', () => {
         customThemes: {},
         mcpServers: {},
         includeDirectories: [],
+        chatCompression: {},
       });
     });
 
@@ -251,6 +255,7 @@ describe('Settings Loading and Merging', () => {
         customThemes: {},
         mcpServers: {},
         includeDirectories: [],
+        chatCompression: {},
       });
     });
 
@@ -301,6 +306,7 @@ describe('Settings Loading and Merging', () => {
         customThemes: {},
         mcpServers: {},
         includeDirectories: [],
+        chatCompression: {},
       });
     });
 
@@ -622,6 +628,116 @@ describe('Settings Loading and Merging', () => {
       expect(settings.merged.mcpServers).toEqual({});
     });
 
+    it('should merge chatCompression settings, with workspace taking precedence', () => {
+      (mockFsExistsSync as Mock).mockReturnValue(true);
+      const userSettingsContent = {
+        chatCompression: { contextPercentageThreshold: 0.5 },
+      };
+      const workspaceSettingsContent = {
+        chatCompression: { contextPercentageThreshold: 0.8 },
+      };
+
+      (fs.readFileSync as Mock).mockImplementation(
+        (p: fs.PathOrFileDescriptor) => {
+          if (p === USER_SETTINGS_PATH)
+            return JSON.stringify(userSettingsContent);
+          if (p === MOCK_WORKSPACE_SETTINGS_PATH)
+            return JSON.stringify(workspaceSettingsContent);
+          return '{}';
+        },
+      );
+
+      const settings = loadSettings(MOCK_WORKSPACE_DIR);
+
+      expect(settings.user.settings.chatCompression).toEqual({
+        contextPercentageThreshold: 0.5,
+      });
+      expect(settings.workspace.settings.chatCompression).toEqual({
+        contextPercentageThreshold: 0.8,
+      });
+      expect(settings.merged.chatCompression).toEqual({
+        contextPercentageThreshold: 0.8,
+      });
+    });
+
+    it('should handle chatCompression when only in user settings', () => {
+      (mockFsExistsSync as Mock).mockImplementation(
+        (p: fs.PathLike) => p === USER_SETTINGS_PATH,
+      );
+      const userSettingsContent = {
+        chatCompression: { contextPercentageThreshold: 0.5 },
+      };
+      (fs.readFileSync as Mock).mockImplementation(
+        (p: fs.PathOrFileDescriptor) => {
+          if (p === USER_SETTINGS_PATH)
+            return JSON.stringify(userSettingsContent);
+          return '{}';
+        },
+      );
+
+      const settings = loadSettings(MOCK_WORKSPACE_DIR);
+      expect(settings.merged.chatCompression).toEqual({
+        contextPercentageThreshold: 0.5,
+      });
+    });
+
+    it('should have chatCompression as an empty object if not in any settings file', () => {
+      (mockFsExistsSync as Mock).mockReturnValue(false); // No settings files exist
+      (fs.readFileSync as Mock).mockReturnValue('{}');
+      const settings = loadSettings(MOCK_WORKSPACE_DIR);
+      expect(settings.merged.chatCompression).toEqual({});
+    });
+
+    it('should ignore chatCompression if contextPercentageThreshold is invalid', () => {
+      const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+      (mockFsExistsSync as Mock).mockImplementation(
+        (p: fs.PathLike) => p === USER_SETTINGS_PATH,
+      );
+      const userSettingsContent = {
+        chatCompression: { contextPercentageThreshold: 1.5 },
+      };
+      (fs.readFileSync as Mock).mockImplementation(
+        (p: fs.PathOrFileDescriptor) => {
+          if (p === USER_SETTINGS_PATH)
+            return JSON.stringify(userSettingsContent);
+          return '{}';
+        },
+      );
+
+      const settings = loadSettings(MOCK_WORKSPACE_DIR);
+      expect(settings.merged.chatCompression).toBeUndefined();
+      expect(warnSpy).toHaveBeenCalledWith(
+        'Invalid value for chatCompression.contextPercentageThreshold: "1.5". Please use a value between 0 and 1. Using default compression settings.',
+      );
+      warnSpy.mockRestore();
+    });
+
+    it('should deep merge chatCompression settings', () => {
+      (mockFsExistsSync as Mock).mockReturnValue(true);
+      const userSettingsContent = {
+        chatCompression: { contextPercentageThreshold: 0.5 },
+      };
+      const workspaceSettingsContent = {
+        chatCompression: {},
+      };
+
+      (fs.readFileSync as Mock).mockImplementation(
+        (p: fs.PathOrFileDescriptor) => {
+          if (p === USER_SETTINGS_PATH)
+            return JSON.stringify(userSettingsContent);
+          if (p === MOCK_WORKSPACE_SETTINGS_PATH)
+            return JSON.stringify(workspaceSettingsContent);
+          return '{}';
+        },
+      );
+
+      const settings = loadSettings(MOCK_WORKSPACE_DIR);
+
+      expect(settings.merged.chatCompression).toEqual({
+        contextPercentageThreshold: 0.5,
+      });
+    });
+
     it('should merge includeDirectories from all scopes', () => {
       (mockFsExistsSync as Mock).mockReturnValue(true);
       const systemSettingsContent = {
@@ -695,6 +811,7 @@ describe('Settings Loading and Merging', () => {
         customThemes: {},
         mcpServers: {},
         includeDirectories: [],
+        chatCompression: {},
       });
 
       // Check that error objects are populated in settings.errors
@@ -1132,6 +1249,7 @@ describe('Settings Loading and Merging', () => {
           customThemes: {},
           mcpServers: {},
           includeDirectories: [],
+          chatCompression: {},
         });
       });
     });
diff --git a/packages/cli/src/config/settings.ts b/packages/cli/src/config/settings.ts
index 64500845..8005ad65 100644
--- a/packages/cli/src/config/settings.ts
+++ b/packages/cli/src/config/settings.ts
@@ -13,6 +13,7 @@ import {
   GEMINI_CONFIG_DIR as GEMINI_DIR,
   getErrorMessage,
   BugCommandSettings,
+  ChatCompressionSettings,
   TelemetrySettings,
   AuthType,
 } from '@google/gemini-cli-core';
@@ -134,6 +135,8 @@ export interface Settings {
   includeDirectories?: string[];
 
   loadMemoryFromIncludeDirectories?: boolean;
+
+  chatCompression?: ChatCompressionSettings;
 }
 
 export interface SettingsError {
@@ -194,6 +197,11 @@ export class LoadedSettings {
         ...(user.includeDirectories || []),
         ...(workspace.includeDirectories || []),
       ],
+      chatCompression: {
+        ...(system.chatCompression || {}),
+        ...(user.chatCompression || {}),
+        ...(workspace.chatCompression || {}),
+      },
     };
   }
 
@@ -482,6 +490,19 @@ export function loadSettings(workspaceDir: string): LoadedSettings {
     settingsErrors,
   );
 
+  // Validate chatCompression settings
+  const chatCompression = loadedSettings.merged.chatCompression;
+  const threshold = chatCompression?.contextPercentageThreshold;
+  if (
+    threshold != null &&
+    (typeof threshold !== 'number' || threshold < 0 || threshold > 1)
+  ) {
+    console.warn(
+      `Invalid value for chatCompression.contextPercentageThreshold: "${threshold}". Please use a value between 0 and 1. Using default compression settings.`,
+    );
+    delete loadedSettings.merged.chatCompression;
+  }
+
   // Load environment with merged settings
   loadEnvironment(loadedSettings.merged);
 
diff --git a/packages/core/src/config/config.ts b/packages/core/src/config/config.ts
index 005573da..4848bfb6 100644
--- a/packages/core/src/config/config.ts
+++ b/packages/core/src/config/config.ts
@@ -69,6 +69,10 @@ export interface BugCommandSettings {
   urlTemplate: string;
 }
 
+export interface ChatCompressionSettings {
+  contextPercentageThreshold?: number;
+}
+
 export interface SummarizeToolOutputSettings {
   tokenBudget?: number;
 }
@@ -191,6 +195,7 @@ export interface ConfigParameters {
   folderTrustFeature?: boolean;
   ideMode?: boolean;
   loadMemoryFromIncludeDirectories?: boolean;
+  chatCompression?: ChatCompressionSettings;
 }
 
 export class Config {
@@ -252,6 +257,7 @@ export class Config {
     | undefined;
   private readonly experimentalAcp: boolean = false;
   private readonly loadMemoryFromIncludeDirectories: boolean = false;
+  private readonly chatCompression: ChatCompressionSettings | undefined;
 
   constructor(params: ConfigParameters) {
     this.sessionId = params.sessionId;
@@ -316,6 +322,7 @@ export class Config {
     }
     this.loadMemoryFromIncludeDirectories =
       params.loadMemoryFromIncludeDirectories ?? false;
+    this.chatCompression = params.chatCompression;
 
     if (params.contextFileName) {
       setGeminiMdFilename(params.contextFileName);
@@ -667,6 +674,10 @@ export class Config {
     return this.ideClient;
   }
 
+  getChatCompression(): ChatCompressionSettings | undefined {
+    return this.chatCompression;
+  }
+
   async getGitService(): Promise<GitService> {
     if (!this.gitService) {
       this.gitService = new GitService(this.targetDir);
diff --git a/packages/core/src/core/client.test.ts b/packages/core/src/core/client.test.ts
index 1e39758a..ff901a8b 100644
--- a/packages/core/src/core/client.test.ts
+++ b/packages/core/src/core/client.test.ts
@@ -206,6 +206,7 @@ describe('Gemini Client (client.ts)', () => {
       }),
       getGeminiClient: vi.fn(),
       setFallbackMode: vi.fn(),
+      getChatCompression: vi.fn().mockReturnValue(undefined),
     };
     const MockedConfig = vi.mocked(Config, true);
     MockedConfig.mockImplementation(
@@ -531,14 +532,19 @@ describe('Gemini Client (client.ts)', () => {
       expect(newChat).toBe(initialChat);
     });
 
-    it('should trigger summarization if token count is at threshold', async () => {
+    it('should trigger summarization if token count is at threshold with contextPercentageThreshold setting', async () => {
       const MOCKED_TOKEN_LIMIT = 1000;
+      const MOCKED_CONTEXT_PERCENTAGE_THRESHOLD = 0.5;
       vi.mocked(tokenLimit).mockReturnValue(MOCKED_TOKEN_LIMIT);
+      vi.spyOn(client['config'], 'getChatCompression').mockReturnValue({
+        contextPercentageThreshold: MOCKED_CONTEXT_PERCENTAGE_THRESHOLD,
+      });
       mockGetHistory.mockReturnValue([
         { role: 'user', parts: [{ text: '...history...' }] },
       ]);
 
-      const originalTokenCount = 1000 * 0.7;
+      const originalTokenCount =
+        MOCKED_TOKEN_LIMIT * MOCKED_CONTEXT_PERCENTAGE_THRESHOLD;
       const newTokenCount = 100;
 
       mockCountTokens
diff --git a/packages/core/src/core/client.ts b/packages/core/src/core/client.ts
index a16a72cc..13e60039 100644
--- a/packages/core/src/core/client.ts
+++ b/packages/core/src/core/client.ts
@@ -596,12 +596,16 @@ export class GeminiClient {
       return null;
     }
 
+    const contextPercentageThreshold =
+      this.config.getChatCompression()?.contextPercentageThreshold;
+
     // Don't compress if not forced and we are under the limit.
-    if (
-      !force &&
-      originalTokenCount < this.COMPRESSION_TOKEN_THRESHOLD * tokenLimit(model)
-    ) {
-      return null;
+    if (!force) {
+      const threshold =
+        contextPercentageThreshold ?? this.COMPRESSION_TOKEN_THRESHOLD;
+      if (originalTokenCount < threshold * tokenLimit(model)) {
+        return null;
+      }
     }
 
     let compressBeforeIndex = findIndexAfterFraction(

From 8d848dca4a52d169b3dfea2f66e7e5f69ee5e45c Mon Sep 17 00:00:00 2001
From: Lee James <40045512+leehagoodjames@users.noreply.github.com>
Date: Thu, 7 Aug 2025 12:00:46 -0400
Subject: [PATCH 034/107] feat: open repo secrets page in addition to README
 (#5684)

---
 .../ui/commands/setupGithubCommand.test.ts    |  9 ++++-
 .../cli/src/ui/commands/setupGithubCommand.ts | 29 +++++++++++++-
 .../cli/src/ui/utils/commandUtils.test.ts     | 39 +++++++++++++++++++
 packages/cli/src/ui/utils/commandUtils.ts     | 26 ++++++++++++-
 packages/cli/src/utils/gitUtils.test.ts       | 34 ++++++++++++++++
 packages/cli/src/utils/gitUtils.ts            | 25 ++++++++++++
 6 files changed, 158 insertions(+), 4 deletions(-)

diff --git a/packages/cli/src/ui/commands/setupGithubCommand.test.ts b/packages/cli/src/ui/commands/setupGithubCommand.test.ts
index 6417c60a..be0a657f 100644
--- a/packages/cli/src/ui/commands/setupGithubCommand.test.ts
+++ b/packages/cli/src/ui/commands/setupGithubCommand.test.ts
@@ -18,6 +18,7 @@ vi.mock('../../utils/gitUtils.js', () => ({
   isGitHubRepository: vi.fn(),
   getGitRepoRoot: vi.fn(),
   getLatestGitHubRelease: vi.fn(),
+  getGitHubRepoInfo: vi.fn(),
 }));
 
 describe('setupGithubCommand', async () => {
@@ -30,7 +31,9 @@ describe('setupGithubCommand', async () => {
   });
 
   it('returns a tool action to download github workflows and handles paths', async () => {
-    const fakeRepoRoot = '/github.com/fake/repo/root';
+    const fakeRepoOwner = 'fake';
+    const fakeRepoName = 'repo';
+    const fakeRepoRoot = `/github.com/${fakeRepoOwner}/${fakeRepoName}/root`;
     const fakeReleaseVersion = 'v1.2.3';
 
     vi.mocked(gitUtils.isGitHubRepository).mockReturnValueOnce(true);
@@ -38,6 +41,10 @@ describe('setupGithubCommand', async () => {
     vi.mocked(gitUtils.getLatestGitHubRelease).mockResolvedValueOnce(
       fakeReleaseVersion,
     );
+    vi.mocked(gitUtils.getGitHubRepoInfo).mockReturnValue({
+      owner: fakeRepoOwner,
+      repo: fakeRepoName,
+    });
 
     const result = (await setupGithubCommand.action?.(
       {} as CommandContext,
diff --git a/packages/cli/src/ui/commands/setupGithubCommand.ts b/packages/cli/src/ui/commands/setupGithubCommand.ts
index 1b5b3277..84d6b5af 100644
--- a/packages/cli/src/ui/commands/setupGithubCommand.ts
+++ b/packages/cli/src/ui/commands/setupGithubCommand.ts
@@ -11,6 +11,7 @@ import {
   getGitRepoRoot,
   getLatestGitHubRelease,
   isGitHubRepository,
+  getGitHubRepoInfo,
 } from '../../utils/gitUtils.js';
 
 import {
@@ -18,6 +19,27 @@ import {
   SlashCommand,
   SlashCommandActionReturn,
 } from './types.js';
+import { getUrlOpenCommand } from '../../ui/utils/commandUtils.js';
+
+// Generate OS-specific commands to open the GitHub pages needed for setup.
+function getOpenUrlsCommands(readmeUrl: string): string[] {
+  // Determine the OS-specific command to open URLs, ex: 'open', 'xdg-open', etc
+  const openCmd = getUrlOpenCommand();
+
+  // Build a list of URLs to open
+  const urlsToOpen = [readmeUrl];
+
+  const repoInfo = getGitHubRepoInfo();
+  if (repoInfo) {
+    urlsToOpen.push(
+      `https://github.com/${repoInfo.owner}/${repoInfo.repo}/settings/secrets/actions`,
+    );
+  }
+
+  // Create and join the individual commands
+  const commands = urlsToOpen.map((url) => `${openCmd} "${url}"`);
+  return commands;
+}
 
 export const setupGithubCommand: SlashCommand = {
   name: 'setup-github',
@@ -71,11 +93,14 @@ export const setupGithubCommand: SlashCommand = {
       commands.push(curlCommand);
     }
 
+    const readmeUrl = `https://github.com/google-github-actions/run-gemini-cli/blob/${releaseTag}/README.md#quick-start`;
+
     commands.push(
-      `echo "Successfully downloaded ${workflows.length} workflows. Follow the steps in https://github.com/google-github-actions/run-gemini-cli/blob/${releaseTag}/README.md#quick-start (skipping the /setup-github step) to complete setup."`,
-      `open https://github.com/google-github-actions/run-gemini-cli/blob/${releaseTag}/README.md#quick-start`,
+      `echo "Successfully downloaded ${workflows.length} workflows. Follow the steps in ${readmeUrl} (skipping the /setup-github step) to complete setup."`,
     );
 
+    commands.push(...getOpenUrlsCommands(readmeUrl));
+
     const command = `(${commands.join(' && ')})`;
     return {
       type: 'tool',
diff --git a/packages/cli/src/ui/utils/commandUtils.test.ts b/packages/cli/src/ui/utils/commandUtils.test.ts
index 4bd48cee..db333e72 100644
--- a/packages/cli/src/ui/utils/commandUtils.test.ts
+++ b/packages/cli/src/ui/utils/commandUtils.test.ts
@@ -11,6 +11,7 @@ import {
   isAtCommand,
   isSlashCommand,
   copyToClipboard,
+  getUrlOpenCommand,
 } from './commandUtils.js';
 
 // Mock child_process
@@ -342,4 +343,42 @@ describe('commandUtils', () => {
       });
     });
   });
+
+  describe('getUrlOpenCommand', () => {
+    describe('on macOS (darwin)', () => {
+      beforeEach(() => {
+        mockProcess.platform = 'darwin';
+      });
+      it('should return open', () => {
+        expect(getUrlOpenCommand()).toBe('open');
+      });
+    });
+
+    describe('on Windows (win32)', () => {
+      beforeEach(() => {
+        mockProcess.platform = 'win32';
+      });
+      it('should return start', () => {
+        expect(getUrlOpenCommand()).toBe('start');
+      });
+    });
+
+    describe('on Linux (linux)', () => {
+      beforeEach(() => {
+        mockProcess.platform = 'linux';
+      });
+      it('should return xdg-open', () => {
+        expect(getUrlOpenCommand()).toBe('xdg-open');
+      });
+    });
+
+    describe('on unmatched OS', () => {
+      beforeEach(() => {
+        mockProcess.platform = 'unmatched';
+      });
+      it('should return xdg-open', () => {
+        expect(getUrlOpenCommand()).toBe('xdg-open');
+      });
+    });
+  });
 });
diff --git a/packages/cli/src/ui/utils/commandUtils.ts b/packages/cli/src/ui/utils/commandUtils.ts
index 4280388f..80ed51ae 100644
--- a/packages/cli/src/ui/utils/commandUtils.ts
+++ b/packages/cli/src/ui/utils/commandUtils.ts
@@ -27,7 +27,7 @@ export const isAtCommand = (query: string): boolean =>
  */
 export const isSlashCommand = (query: string): boolean => query.startsWith('/');
 
-//Copies a string snippet to the clipboard for different platforms
+// Copies a string snippet to the clipboard for different platforms
 export const copyToClipboard = async (text: string): Promise<void> => {
   const run = (cmd: string, args: string[]) =>
     new Promise<void>((resolve, reject) => {
@@ -80,3 +80,27 @@ export const copyToClipboard = async (text: string): Promise<void> => {
       throw new Error(`Unsupported platform: ${process.platform}`);
   }
 };
+
+export const getUrlOpenCommand = (): string => {
+  // --- Determine the OS-specific command to open URLs ---
+  let openCmd: string;
+  switch (process.platform) {
+    case 'darwin':
+      openCmd = 'open';
+      break;
+    case 'win32':
+      openCmd = 'start';
+      break;
+    case 'linux':
+      openCmd = 'xdg-open';
+      break;
+    default:
+      // Default to xdg-open, which appears to be supported for the less popular operating systems.
+      openCmd = 'xdg-open';
+      console.warn(
+        `Unknown platform: ${process.platform}. Attempting to open URLs with: ${openCmd}.`,
+      );
+      break;
+  }
+  return openCmd;
+};
diff --git a/packages/cli/src/utils/gitUtils.test.ts b/packages/cli/src/utils/gitUtils.test.ts
index 4a29f589..7a5f210c 100644
--- a/packages/cli/src/utils/gitUtils.test.ts
+++ b/packages/cli/src/utils/gitUtils.test.ts
@@ -10,6 +10,7 @@ import {
   isGitHubRepository,
   getGitRepoRoot,
   getLatestGitHubRelease,
+  getGitHubRepoInfo,
 } from './gitUtils.js';
 
 vi.mock('child_process');
@@ -44,6 +45,39 @@ describe('isGitHubRepository', async () => {
   });
 });
 
+describe('getGitHubRepoInfo', async () => {
+  beforeEach(() => {
+    vi.resetAllMocks();
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it('throws an error if github repo info cannot be determined', async () => {
+    vi.mocked(child_process.execSync).mockImplementation((): string => {
+      throw new Error('oops');
+    });
+    expect(() => {
+      getGitHubRepoInfo();
+    }).toThrowError(/oops/);
+  });
+
+  it('throws an error if owner/repo could not be determined', async () => {
+    vi.mocked(child_process.execSync).mockReturnValueOnce('');
+    expect(() => {
+      getGitHubRepoInfo();
+    }).toThrowError(/Owner & repo could not be extracted from remote URL/);
+  });
+
+  it('returns the owner and repo', async () => {
+    vi.mocked(child_process.execSync).mockReturnValueOnce(
+      'https://github.com/owner/repo.git ',
+    );
+    expect(getGitHubRepoInfo()).toEqual({ owner: 'owner', repo: 'repo' });
+  });
+});
+
 describe('getGitRepoRoot', async () => {
   beforeEach(() => {
     vi.resetAllMocks();
diff --git a/packages/cli/src/utils/gitUtils.ts b/packages/cli/src/utils/gitUtils.ts
index 30ca2245..f5f9cb92 100644
--- a/packages/cli/src/utils/gitUtils.ts
+++ b/packages/cli/src/utils/gitUtils.ts
@@ -91,3 +91,28 @@ export const getLatestGitHubRelease = async (
     );
   }
 };
+
+/**
+ * getGitHubRepoInfo returns the owner and repository for a GitHub repo.
+ * @returns the owner and repository of the github repo.
+ * @throws error if the exec command fails.
+ */
+export function getGitHubRepoInfo(): { owner: string; repo: string } {
+  const remoteUrl = execSync('git remote get-url origin', {
+    encoding: 'utf-8',
+  }).trim();
+
+  // Matches either https://github.com/owner/repo.git or git@github.com:owner/repo.git
+  const match = remoteUrl.match(
+    /(?:https?:\/\/|git@)github\.com(?::|\/)([^/]+)\/([^/]+?)(?:\.git)?$/,
+  );
+
+  // If the regex fails match, throw an error.
+  if (!match || !match[1] || !match[2]) {
+    throw new Error(
+      `Owner & repo could not be extracted from remote URL: ${remoteUrl}`,
+    );
+  }
+
+  return { owner: match[1], repo: match[2] };
+}

From 0d65baf9283138da56cdf08b00058ab3cf8cbaf9 Mon Sep 17 00:00:00 2001
From: Sandy Tao <sandytao520@icloud.com>
Date: Thu, 7 Aug 2025 09:18:53 -0700
Subject: [PATCH 035/107] Fix(core): Use Flash for next speaker check (#5786)

---
 packages/core/src/utils/nextSpeakerChecker.test.ts | 4 ++--
 packages/core/src/utils/nextSpeakerChecker.ts      | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/packages/core/src/utils/nextSpeakerChecker.test.ts b/packages/core/src/utils/nextSpeakerChecker.test.ts
index 70d6023f..9141105f 100644
--- a/packages/core/src/utils/nextSpeakerChecker.test.ts
+++ b/packages/core/src/utils/nextSpeakerChecker.test.ts
@@ -6,7 +6,7 @@
 
 import { describe, it, expect, vi, beforeEach, Mock, afterEach } from 'vitest';
 import { Content, GoogleGenAI, Models } from '@google/genai';
-import { DEFAULT_GEMINI_FLASH_LITE_MODEL } from '../config/models.js';
+import { DEFAULT_GEMINI_FLASH_MODEL } from '../config/models.js';
 import { GeminiClient } from '../core/client.js';
 import { Config } from '../config/config.js';
 import { checkNextSpeaker, NextSpeakerResponse } from './nextSpeakerChecker.js';
@@ -248,6 +248,6 @@ describe('checkNextSpeaker', () => {
     expect(mockGeminiClient.generateJson).toHaveBeenCalled();
     const generateJsonCall = (mockGeminiClient.generateJson as Mock).mock
       .calls[0];
-    expect(generateJsonCall[3]).toBe(DEFAULT_GEMINI_FLASH_LITE_MODEL);
+    expect(generateJsonCall[3]).toBe(DEFAULT_GEMINI_FLASH_MODEL);
   });
 });
diff --git a/packages/core/src/utils/nextSpeakerChecker.ts b/packages/core/src/utils/nextSpeakerChecker.ts
index a0d735b0..8497db61 100644
--- a/packages/core/src/utils/nextSpeakerChecker.ts
+++ b/packages/core/src/utils/nextSpeakerChecker.ts
@@ -5,7 +5,7 @@
  */
 
 import { Content, SchemaUnion, Type } from '@google/genai';
-import { DEFAULT_GEMINI_FLASH_LITE_MODEL } from '../config/models.js';
+import { DEFAULT_GEMINI_FLASH_MODEL } from '../config/models.js';
 import { GeminiClient } from '../core/client.js';
 import { GeminiChat } from '../core/geminiChat.js';
 import { isFunctionResponse } from './messageInspectors.js';
@@ -112,7 +112,7 @@ export async function checkNextSpeaker(
       contents,
       RESPONSE_SCHEMA,
       abortSignal,
-      DEFAULT_GEMINI_FLASH_LITE_MODEL,
+      DEFAULT_GEMINI_FLASH_MODEL,
     )) as unknown as NextSpeakerResponse;
 
     if (

From 8bac9e7d048c7ff97f0942b23edb0167ee6ca83e Mon Sep 17 00:00:00 2001
From: joshualitt <joshualitt@google.com>
Date: Thu, 7 Aug 2025 10:05:37 -0700
Subject: [PATCH 036/107] Migrate EditTool, GrepTool, and GlobTool to
 DeclarativeTool (#5744)

---
 packages/core/src/tools/edit.test.ts | 162 +++++++------
 packages/core/src/tools/edit.ts      | 300 ++++++++++++------------
 packages/core/src/tools/glob.test.ts |  34 ++-
 packages/core/src/tools/glob.ts      | 331 ++++++++++++++-------------
 packages/core/src/tools/grep.test.ts |  71 +++---
 packages/core/src/tools/grep.ts      | 266 ++++++++++++---------
 packages/core/src/tools/read-file.ts |  20 +-
 packages/core/src/tools/tools.ts     |  28 +++
 8 files changed, 649 insertions(+), 563 deletions(-)

diff --git a/packages/core/src/tools/edit.test.ts b/packages/core/src/tools/edit.test.ts
index 3bfa023e..3e0dba61 100644
--- a/packages/core/src/tools/edit.test.ts
+++ b/packages/core/src/tools/edit.test.ts
@@ -27,7 +27,7 @@ vi.mock('../utils/editor.js', () => ({
 }));
 
 import { describe, it, expect, beforeEach, afterEach, vi, Mock } from 'vitest';
-import { EditTool, EditToolParams } from './edit.js';
+import { applyReplacement, EditTool, EditToolParams } from './edit.js';
 import { FileDiff, ToolConfirmationOutcome } from './tools.js';
 import { ToolErrorType } from './tool-error.js';
 import path from 'path';
@@ -155,45 +155,30 @@ describe('EditTool', () => {
     fs.rmSync(tempDir, { recursive: true, force: true });
   });
 
-  describe('_applyReplacement', () => {
-    // Access private method for testing
-    // Note: `tool` is initialized in `beforeEach` of the parent describe block
+  describe('applyReplacement', () => {
     it('should return newString if isNewFile is true', () => {
-      expect((tool as any)._applyReplacement(null, 'old', 'new', true)).toBe(
-        'new',
-      );
-      expect(
-        (tool as any)._applyReplacement('existing', 'old', 'new', true),
-      ).toBe('new');
+      expect(applyReplacement(null, 'old', 'new', true)).toBe('new');
+      expect(applyReplacement('existing', 'old', 'new', true)).toBe('new');
     });
 
     it('should return newString if currentContent is null and oldString is empty (defensive)', () => {
-      expect((tool as any)._applyReplacement(null, '', 'new', false)).toBe(
-        'new',
-      );
+      expect(applyReplacement(null, '', 'new', false)).toBe('new');
     });
 
     it('should return empty string if currentContent is null and oldString is not empty (defensive)', () => {
-      expect((tool as any)._applyReplacement(null, 'old', 'new', false)).toBe(
-        '',
-      );
+      expect(applyReplacement(null, 'old', 'new', false)).toBe('');
     });
 
     it('should replace oldString with newString in currentContent', () => {
-      expect(
-        (tool as any)._applyReplacement(
-          'hello old world old',
-          'old',
-          'new',
-          false,
-        ),
-      ).toBe('hello new world new');
+      expect(applyReplacement('hello old world old', 'old', 'new', false)).toBe(
+        'hello new world new',
+      );
     });
 
     it('should return currentContent if oldString is empty and not a new file', () => {
-      expect(
-        (tool as any)._applyReplacement('hello world', '', 'new', false),
-      ).toBe('hello world');
+      expect(applyReplacement('hello world', '', 'new', false)).toBe(
+        'hello world',
+      );
     });
   });
 
@@ -239,15 +224,13 @@ describe('EditTool', () => {
       filePath = path.join(rootDir, testFile);
     });
 
-    it('should return false if params are invalid', async () => {
+    it('should throw an error if params are invalid', async () => {
       const params: EditToolParams = {
         file_path: 'relative.txt',
         old_string: 'old',
         new_string: 'new',
       };
-      expect(
-        await tool.shouldConfirmExecute(params, new AbortController().signal),
-      ).toBe(false);
+      expect(() => tool.build(params)).toThrow();
     });
 
     it('should request confirmation for valid edit', async () => {
@@ -259,8 +242,8 @@ describe('EditTool', () => {
       };
       // ensureCorrectEdit will be called by shouldConfirmExecute
       mockEnsureCorrectEdit.mockResolvedValueOnce({ params, occurrences: 1 });
-      const confirmation = await tool.shouldConfirmExecute(
-        params,
+      const invocation = tool.build(params);
+      const confirmation = await invocation.shouldConfirmExecute(
         new AbortController().signal,
       );
       expect(confirmation).toEqual(
@@ -280,9 +263,11 @@ describe('EditTool', () => {
         new_string: 'new',
       };
       mockEnsureCorrectEdit.mockResolvedValueOnce({ params, occurrences: 0 });
-      expect(
-        await tool.shouldConfirmExecute(params, new AbortController().signal),
-      ).toBe(false);
+      const invocation = tool.build(params);
+      const confirmation = await invocation.shouldConfirmExecute(
+        new AbortController().signal,
+      );
+      expect(confirmation).toBe(false);
     });
 
     it('should return false if multiple occurrences of old_string are found (ensureCorrectEdit returns > 1)', async () => {
@@ -293,9 +278,11 @@ describe('EditTool', () => {
         new_string: 'new',
       };
       mockEnsureCorrectEdit.mockResolvedValueOnce({ params, occurrences: 2 });
-      expect(
-        await tool.shouldConfirmExecute(params, new AbortController().signal),
-      ).toBe(false);
+      const invocation = tool.build(params);
+      const confirmation = await invocation.shouldConfirmExecute(
+        new AbortController().signal,
+      );
+      expect(confirmation).toBe(false);
     });
 
     it('should request confirmation for creating a new file (empty old_string)', async () => {
@@ -310,8 +297,8 @@ describe('EditTool', () => {
       // as shouldConfirmExecute handles this for diff generation.
       // If it is called, it should return 0 occurrences for a new file.
       mockEnsureCorrectEdit.mockResolvedValueOnce({ params, occurrences: 0 });
-      const confirmation = await tool.shouldConfirmExecute(
-        params,
+      const invocation = tool.build(params);
+      const confirmation = await invocation.shouldConfirmExecute(
         new AbortController().signal,
       );
       expect(confirmation).toEqual(
@@ -358,9 +345,8 @@ describe('EditTool', () => {
           };
         },
       );
-
-      const confirmation = (await tool.shouldConfirmExecute(
-        params,
+      const invocation = tool.build(params);
+      const confirmation = (await invocation.shouldConfirmExecute(
         new AbortController().signal,
       )) as FileDiff;
 
@@ -408,15 +394,13 @@ describe('EditTool', () => {
       });
     });
 
-    it('should return error if params are invalid', async () => {
+    it('should throw error if params are invalid', async () => {
       const params: EditToolParams = {
         file_path: 'relative.txt',
         old_string: 'old',
         new_string: 'new',
       };
-      const result = await tool.execute(params, new AbortController().signal);
-      expect(result.llmContent).toMatch(/Error: Invalid parameters provided/);
-      expect(result.returnDisplay).toMatch(/Error: File path must be absolute/);
+      expect(() => tool.build(params)).toThrow(/File path must be absolute/);
     });
 
     it('should edit an existing file and return diff with fileName', async () => {
@@ -433,12 +417,8 @@ describe('EditTool', () => {
       // ensureCorrectEdit is NOT called by calculateEdit, only by shouldConfirmExecute
       // So, the default mockEnsureCorrectEdit should correctly return 1 occurrence for 'old' in initialContent
 
-      // Simulate confirmation by setting shouldAlwaysEdit
-      (tool as any).shouldAlwaysEdit = true;
-
-      const result = await tool.execute(params, new AbortController().signal);
-
-      (tool as any).shouldAlwaysEdit = false; // Reset for other tests
+      const invocation = tool.build(params);
+      const result = await invocation.execute(new AbortController().signal);
 
       expect(result.llmContent).toMatch(/Successfully modified file/);
       expect(fs.readFileSync(filePath, 'utf8')).toBe(newContent);
@@ -461,7 +441,8 @@ describe('EditTool', () => {
       (mockConfig.getApprovalMode as Mock).mockReturnValueOnce(
         ApprovalMode.AUTO_EDIT,
       );
-      const result = await tool.execute(params, new AbortController().signal);
+      const invocation = tool.build(params);
+      const result = await invocation.execute(new AbortController().signal);
 
       expect(result.llmContent).toMatch(/Created new file/);
       expect(fs.existsSync(newFilePath)).toBe(true);
@@ -477,7 +458,8 @@ describe('EditTool', () => {
         new_string: 'replacement',
       };
       // The default mockEnsureCorrectEdit will return 0 occurrences for 'nonexistent'
-      const result = await tool.execute(params, new AbortController().signal);
+      const invocation = tool.build(params);
+      const result = await invocation.execute(new AbortController().signal);
       expect(result.llmContent).toMatch(
         /0 occurrences found for old_string in/,
       );
@@ -494,7 +476,8 @@ describe('EditTool', () => {
         new_string: 'new',
       };
       // The default mockEnsureCorrectEdit will return 2 occurrences for 'old'
-      const result = await tool.execute(params, new AbortController().signal);
+      const invocation = tool.build(params);
+      const result = await invocation.execute(new AbortController().signal);
       expect(result.llmContent).toMatch(
         /Expected 1 occurrence but found 2 for old_string in file/,
       );
@@ -512,12 +495,8 @@ describe('EditTool', () => {
         expected_replacements: 3,
       };
 
-      // Simulate confirmation by setting shouldAlwaysEdit
-      (tool as any).shouldAlwaysEdit = true;
-
-      const result = await tool.execute(params, new AbortController().signal);
-
-      (tool as any).shouldAlwaysEdit = false; // Reset for other tests
+      const invocation = tool.build(params);
+      const result = await invocation.execute(new AbortController().signal);
 
       expect(result.llmContent).toMatch(/Successfully modified file/);
       expect(fs.readFileSync(filePath, 'utf8')).toBe(
@@ -537,7 +516,8 @@ describe('EditTool', () => {
         new_string: 'new',
         expected_replacements: 3, // Expecting 3 but only 2 exist
       };
-      const result = await tool.execute(params, new AbortController().signal);
+      const invocation = tool.build(params);
+      const result = await invocation.execute(new AbortController().signal);
       expect(result.llmContent).toMatch(
         /Expected 3 occurrences but found 2 for old_string in file/,
       );
@@ -553,7 +533,8 @@ describe('EditTool', () => {
         old_string: '',
         new_string: 'new content',
       };
-      const result = await tool.execute(params, new AbortController().signal);
+      const invocation = tool.build(params);
+      const result = await invocation.execute(new AbortController().signal);
       expect(result.llmContent).toMatch(/File already exists, cannot create/);
       expect(result.returnDisplay).toMatch(
         /Attempted to create a file that already exists/,
@@ -573,7 +554,8 @@ describe('EditTool', () => {
       (mockConfig.getApprovalMode as Mock).mockReturnValueOnce(
         ApprovalMode.AUTO_EDIT,
       );
-      const result = await tool.execute(params, new AbortController().signal);
+      const invocation = tool.build(params);
+      const result = await invocation.execute(new AbortController().signal);
 
       expect(result.llmContent).toMatch(
         /User modified the `new_string` content/,
@@ -593,7 +575,8 @@ describe('EditTool', () => {
       (mockConfig.getApprovalMode as Mock).mockReturnValueOnce(
         ApprovalMode.AUTO_EDIT,
       );
-      const result = await tool.execute(params, new AbortController().signal);
+      const invocation = tool.build(params);
+      const result = await invocation.execute(new AbortController().signal);
 
       expect(result.llmContent).not.toMatch(
         /User modified the `new_string` content/,
@@ -612,7 +595,8 @@ describe('EditTool', () => {
       (mockConfig.getApprovalMode as Mock).mockReturnValueOnce(
         ApprovalMode.AUTO_EDIT,
       );
-      const result = await tool.execute(params, new AbortController().signal);
+      const invocation = tool.build(params);
+      const result = await invocation.execute(new AbortController().signal);
 
       expect(result.llmContent).not.toMatch(
         /User modified the `new_string` content/,
@@ -627,7 +611,8 @@ describe('EditTool', () => {
         old_string: 'identical',
         new_string: 'identical',
       };
-      const result = await tool.execute(params, new AbortController().signal);
+      const invocation = tool.build(params);
+      const result = await invocation.execute(new AbortController().signal);
       expect(result.llmContent).toMatch(/No changes to apply/);
       expect(result.returnDisplay).toMatch(/No changes to apply/);
     });
@@ -647,7 +632,8 @@ describe('EditTool', () => {
         old_string: 'any',
         new_string: 'new',
       };
-      const result = await tool.execute(params, new AbortController().signal);
+      const invocation = tool.build(params);
+      const result = await invocation.execute(new AbortController().signal);
       expect(result.error?.type).toBe(ToolErrorType.FILE_NOT_FOUND);
     });
 
@@ -658,7 +644,8 @@ describe('EditTool', () => {
         old_string: '',
         new_string: 'new content',
       };
-      const result = await tool.execute(params, new AbortController().signal);
+      const invocation = tool.build(params);
+      const result = await invocation.execute(new AbortController().signal);
       expect(result.error?.type).toBe(
         ToolErrorType.ATTEMPT_TO_CREATE_EXISTING_FILE,
       );
@@ -671,7 +658,8 @@ describe('EditTool', () => {
         old_string: 'not-found',
         new_string: 'new',
       };
-      const result = await tool.execute(params, new AbortController().signal);
+      const invocation = tool.build(params);
+      const result = await invocation.execute(new AbortController().signal);
       expect(result.error?.type).toBe(ToolErrorType.EDIT_NO_OCCURRENCE_FOUND);
     });
 
@@ -683,7 +671,8 @@ describe('EditTool', () => {
         new_string: 'new',
         expected_replacements: 3,
       };
-      const result = await tool.execute(params, new AbortController().signal);
+      const invocation = tool.build(params);
+      const result = await invocation.execute(new AbortController().signal);
       expect(result.error?.type).toBe(
         ToolErrorType.EDIT_EXPECTED_OCCURRENCE_MISMATCH,
       );
@@ -696,18 +685,18 @@ describe('EditTool', () => {
         old_string: 'content',
         new_string: 'content',
       };
-      const result = await tool.execute(params, new AbortController().signal);
+      const invocation = tool.build(params);
+      const result = await invocation.execute(new AbortController().signal);
       expect(result.error?.type).toBe(ToolErrorType.EDIT_NO_CHANGE);
     });
 
-    it('should return INVALID_PARAMETERS error for relative path', async () => {
+    it('should throw INVALID_PARAMETERS error for relative path', async () => {
       const params: EditToolParams = {
         file_path: 'relative/path.txt',
         old_string: 'a',
         new_string: 'b',
       };
-      const result = await tool.execute(params, new AbortController().signal);
-      expect(result.error?.type).toBe(ToolErrorType.INVALID_TOOL_PARAMS);
+      expect(() => tool.build(params)).toThrow();
     });
 
     it('should return FILE_WRITE_FAILURE on write error', async () => {
@@ -720,7 +709,8 @@ describe('EditTool', () => {
         old_string: 'content',
         new_string: 'new content',
       };
-      const result = await tool.execute(params, new AbortController().signal);
+      const invocation = tool.build(params);
+      const result = await invocation.execute(new AbortController().signal);
       expect(result.error?.type).toBe(ToolErrorType.FILE_WRITE_FAILURE);
     });
   });
@@ -733,8 +723,9 @@ describe('EditTool', () => {
         old_string: 'identical_string',
         new_string: 'identical_string',
       };
+      const invocation = tool.build(params);
       // shortenPath will be called internally, resulting in just the file name
-      expect(tool.getDescription(params)).toBe(
+      expect(invocation.getDescription()).toBe(
         `No file changes to ${testFileName}`,
       );
     });
@@ -746,9 +737,10 @@ describe('EditTool', () => {
         old_string: 'this is the old string value',
         new_string: 'this is the new string value',
       };
+      const invocation = tool.build(params);
       // shortenPath will be called internally, resulting in just the file name
       // The snippets are truncated at 30 chars + '...'
-      expect(tool.getDescription(params)).toBe(
+      expect(invocation.getDescription()).toBe(
         `${testFileName}: this is the old string value => this is the new string value`,
       );
     });
@@ -760,7 +752,8 @@ describe('EditTool', () => {
         old_string: 'old',
         new_string: 'new',
       };
-      expect(tool.getDescription(params)).toBe(`${testFileName}: old => new`);
+      const invocation = tool.build(params);
+      expect(invocation.getDescription()).toBe(`${testFileName}: old => new`);
     });
 
     it('should truncate long strings in the description', () => {
@@ -772,7 +765,8 @@ describe('EditTool', () => {
         new_string:
           'this is a very long new string that will also be truncated',
       };
-      expect(tool.getDescription(params)).toBe(
+      const invocation = tool.build(params);
+      expect(invocation.getDescription()).toBe(
         `${testFileName}: this is a very long old string... => this is a very long new string...`,
       );
     });
@@ -839,8 +833,8 @@ describe('EditTool', () => {
         content: modifiedContent,
       });
 
-      const confirmation = await tool.shouldConfirmExecute(
-        params,
+      const invocation = tool.build(params);
+      const confirmation = await invocation.shouldConfirmExecute(
         new AbortController().signal,
       );
 
diff --git a/packages/core/src/tools/edit.ts b/packages/core/src/tools/edit.ts
index 43505182..f1d0498a 100644
--- a/packages/core/src/tools/edit.ts
+++ b/packages/core/src/tools/edit.ts
@@ -8,11 +8,12 @@ import * as fs from 'fs';
 import * as path from 'path';
 import * as Diff from 'diff';
 import {
-  BaseTool,
+  BaseDeclarativeTool,
   Icon,
   ToolCallConfirmationDetails,
   ToolConfirmationOutcome,
   ToolEditConfirmationDetails,
+  ToolInvocation,
   ToolLocation,
   ToolResult,
   ToolResultDisplay,
@@ -29,6 +30,26 @@ import { ReadFileTool } from './read-file.js';
 import { ModifiableDeclarativeTool, ModifyContext } from './modifiable-tool.js';
 import { IDEConnectionStatus } from '../ide/ide-client.js';
 
+export function applyReplacement(
+  currentContent: string | null,
+  oldString: string,
+  newString: string,
+  isNewFile: boolean,
+): string {
+  if (isNewFile) {
+    return newString;
+  }
+  if (currentContent === null) {
+    // Should not happen if not a new file, but defensively return empty or newString if oldString is also empty
+    return oldString === '' ? newString : '';
+  }
+  // If oldString is empty and it's not a new file, do not modify the content.
+  if (oldString === '' && !isNewFile) {
+    return currentContent;
+  }
+  return currentContent.replaceAll(oldString, newString);
+}
+
 /**
  * Parameters for the Edit tool
  */
@@ -68,112 +89,14 @@ interface CalculatedEdit {
   isNewFile: boolean;
 }
 
-/**
- * Implementation of the Edit tool logic
- */
-export class EditTool
-  extends BaseTool<EditToolParams, ToolResult>
-  implements ModifiableDeclarativeTool<EditToolParams>
-{
-  static readonly Name = 'replace';
+class EditToolInvocation implements ToolInvocation<EditToolParams, ToolResult> {
+  constructor(
+    private readonly config: Config,
+    public params: EditToolParams,
+  ) {}
 
-  constructor(private readonly config: Config) {
-    super(
-      EditTool.Name,
-      'Edit',
-      `Replaces text within a file. By default, replaces a single occurrence, but can replace multiple occurrences when \`expected_replacements\` is specified. This tool requires providing significant context around the change to ensure precise targeting. Always use the ${ReadFileTool.Name} tool to examine the file's current content before attempting a text replacement.
-
-      The user has the ability to modify the \`new_string\` content. If modified, this will be stated in the response.
-
-Expectation for required parameters:
-1. \`file_path\` MUST be an absolute path; otherwise an error will be thrown.
-2. \`old_string\` MUST be the exact literal text to replace (including all whitespace, indentation, newlines, and surrounding code etc.).
-3. \`new_string\` MUST be the exact literal text to replace \`old_string\` with (also including all whitespace, indentation, newlines, and surrounding code etc.). Ensure the resulting code is correct and idiomatic.
-4. NEVER escape \`old_string\` or \`new_string\`, that would break the exact literal text requirement.
-**Important:** If ANY of the above are not satisfied, the tool will fail. CRITICAL for \`old_string\`: Must uniquely identify the single instance to change. Include at least 3 lines of context BEFORE and AFTER the target text, matching whitespace and indentation precisely. If this string matches multiple locations, or does not match exactly, the tool will fail.
-**Multiple replacements:** Set \`expected_replacements\` to the number of occurrences you want to replace. The tool will replace ALL occurrences that match \`old_string\` exactly. Ensure the number of replacements matches your expectation.`,
-      Icon.Pencil,
-      {
-        properties: {
-          file_path: {
-            description:
-              "The absolute path to the file to modify. Must start with '/'.",
-            type: Type.STRING,
-          },
-          old_string: {
-            description:
-              'The exact literal text to replace, preferably unescaped. For single replacements (default), include at least 3 lines of context BEFORE and AFTER the target text, matching whitespace and indentation precisely. For multiple replacements, specify expected_replacements parameter. If this string is not the exact literal text (i.e. you escaped it) or does not match exactly, the tool will fail.',
-            type: Type.STRING,
-          },
-          new_string: {
-            description:
-              'The exact literal text to replace `old_string` with, preferably unescaped. Provide the EXACT text. Ensure the resulting code is correct and idiomatic.',
-            type: Type.STRING,
-          },
-          expected_replacements: {
-            type: Type.NUMBER,
-            description:
-              'Number of replacements expected. Defaults to 1 if not specified. Use when you want to replace multiple occurrences.',
-            minimum: 1,
-          },
-        },
-        required: ['file_path', 'old_string', 'new_string'],
-        type: Type.OBJECT,
-      },
-    );
-  }
-
-  /**
-   * Validates the parameters for the Edit tool
-   * @param params Parameters to validate
-   * @returns Error message string or null if valid
-   */
-  validateToolParams(params: EditToolParams): string | null {
-    const errors = SchemaValidator.validate(this.schema.parameters, params);
-    if (errors) {
-      return errors;
-    }
-
-    if (!path.isAbsolute(params.file_path)) {
-      return `File path must be absolute: ${params.file_path}`;
-    }
-
-    const workspaceContext = this.config.getWorkspaceContext();
-    if (!workspaceContext.isPathWithinWorkspace(params.file_path)) {
-      const directories = workspaceContext.getDirectories();
-      return `File path must be within one of the workspace directories: ${directories.join(', ')}`;
-    }
-
-    return null;
-  }
-
-  /**
-   * Determines any file locations affected by the tool execution
-   * @param params Parameters for the tool execution
-   * @returns A list of such paths
-   */
-  toolLocations(params: EditToolParams): ToolLocation[] {
-    return [{ path: params.file_path }];
-  }
-
-  private _applyReplacement(
-    currentContent: string | null,
-    oldString: string,
-    newString: string,
-    isNewFile: boolean,
-  ): string {
-    if (isNewFile) {
-      return newString;
-    }
-    if (currentContent === null) {
-      // Should not happen if not a new file, but defensively return empty or newString if oldString is also empty
-      return oldString === '' ? newString : '';
-    }
-    // If oldString is empty and it's not a new file, do not modify the content.
-    if (oldString === '' && !isNewFile) {
-      return currentContent;
-    }
-    return currentContent.replaceAll(oldString, newString);
+  toolLocations(): ToolLocation[] {
+    return [{ path: this.params.file_path }];
   }
 
   /**
@@ -271,7 +194,7 @@ Expectation for required parameters:
       };
     }
 
-    const newContent = this._applyReplacement(
+    const newContent = applyReplacement(
       currentContent,
       finalOldString,
       finalNewString,
@@ -292,23 +215,15 @@ Expectation for required parameters:
    * It needs to calculate the diff to show the user.
    */
   async shouldConfirmExecute(
-    params: EditToolParams,
     abortSignal: AbortSignal,
   ): Promise<ToolCallConfirmationDetails | false> {
     if (this.config.getApprovalMode() === ApprovalMode.AUTO_EDIT) {
       return false;
     }
-    const validationError = this.validateToolParams(params);
-    if (validationError) {
-      console.error(
-        `[EditTool Wrapper] Attempted confirmation with invalid parameters: ${validationError}`,
-      );
-      return false;
-    }
 
     let editData: CalculatedEdit;
     try {
-      editData = await this.calculateEdit(params, abortSignal);
+      editData = await this.calculateEdit(this.params, abortSignal);
     } catch (error) {
       const errorMsg = error instanceof Error ? error.message : String(error);
       console.log(`Error preparing edit: ${errorMsg}`);
@@ -320,7 +235,7 @@ Expectation for required parameters:
       return false;
     }
 
-    const fileName = path.basename(params.file_path);
+    const fileName = path.basename(this.params.file_path);
     const fileDiff = Diff.createPatch(
       fileName,
       editData.currentContent ?? '',
@@ -334,14 +249,14 @@ Expectation for required parameters:
       this.config.getIdeModeFeature() &&
       this.config.getIdeMode() &&
       ideClient?.getConnectionStatus().status === IDEConnectionStatus.Connected
-        ? ideClient.openDiff(params.file_path, editData.newContent)
+        ? ideClient.openDiff(this.params.file_path, editData.newContent)
         : undefined;
 
     const confirmationDetails: ToolEditConfirmationDetails = {
       type: 'edit',
-      title: `Confirm Edit: ${shortenPath(makeRelative(params.file_path, this.config.getTargetDir()))}`,
+      title: `Confirm Edit: ${shortenPath(makeRelative(this.params.file_path, this.config.getTargetDir()))}`,
       fileName,
-      filePath: params.file_path,
+      filePath: this.params.file_path,
       fileDiff,
       originalContent: editData.currentContent,
       newContent: editData.newContent,
@@ -355,8 +270,8 @@ Expectation for required parameters:
           if (result.status === 'accepted' && result.content) {
             // TODO(chrstn): See https://github.com/google-gemini/gemini-cli/pull/5618#discussion_r2255413084
             // for info on a possible race condition where the file is modified on disk while being edited.
-            params.old_string = editData.currentContent ?? '';
-            params.new_string = result.content;
+            this.params.old_string = editData.currentContent ?? '';
+            this.params.new_string = result.content;
           }
         }
       },
@@ -365,26 +280,23 @@ Expectation for required parameters:
     return confirmationDetails;
   }
 
-  getDescription(params: EditToolParams): string {
-    if (!params.file_path || !params.old_string || !params.new_string) {
-      return `Model did not provide valid parameters for edit tool`;
-    }
+  getDescription(): string {
     const relativePath = makeRelative(
-      params.file_path,
+      this.params.file_path,
       this.config.getTargetDir(),
     );
-    if (params.old_string === '') {
+    if (this.params.old_string === '') {
       return `Create ${shortenPath(relativePath)}`;
     }
 
     const oldStringSnippet =
-      params.old_string.split('\n')[0].substring(0, 30) +
-      (params.old_string.length > 30 ? '...' : '');
+      this.params.old_string.split('\n')[0].substring(0, 30) +
+      (this.params.old_string.length > 30 ? '...' : '');
     const newStringSnippet =
-      params.new_string.split('\n')[0].substring(0, 30) +
-      (params.new_string.length > 30 ? '...' : '');
+      this.params.new_string.split('\n')[0].substring(0, 30) +
+      (this.params.new_string.length > 30 ? '...' : '');
 
-    if (params.old_string === params.new_string) {
+    if (this.params.old_string === this.params.new_string) {
       return `No file changes to ${shortenPath(relativePath)}`;
     }
     return `${shortenPath(relativePath)}: ${oldStringSnippet} => ${newStringSnippet}`;
@@ -395,25 +307,10 @@ Expectation for required parameters:
    * @param params Parameters for the edit operation
    * @returns Result of the edit operation
    */
-  async execute(
-    params: EditToolParams,
-    signal: AbortSignal,
-  ): Promise<ToolResult> {
-    const validationError = this.validateToolParams(params);
-    if (validationError) {
-      return {
-        llmContent: `Error: Invalid parameters provided. Reason: ${validationError}`,
-        returnDisplay: `Error: ${validationError}`,
-        error: {
-          message: validationError,
-          type: ToolErrorType.INVALID_TOOL_PARAMS,
-        },
-      };
-    }
-
+  async execute(signal: AbortSignal): Promise<ToolResult> {
     let editData: CalculatedEdit;
     try {
-      editData = await this.calculateEdit(params, signal);
+      editData = await this.calculateEdit(this.params, signal);
     } catch (error) {
       const errorMsg = error instanceof Error ? error.message : String(error);
       return {
@@ -438,16 +335,16 @@ Expectation for required parameters:
     }
 
     try {
-      this.ensureParentDirectoriesExist(params.file_path);
-      fs.writeFileSync(params.file_path, editData.newContent, 'utf8');
+      this.ensureParentDirectoriesExist(this.params.file_path);
+      fs.writeFileSync(this.params.file_path, editData.newContent, 'utf8');
 
       let displayResult: ToolResultDisplay;
       if (editData.isNewFile) {
-        displayResult = `Created ${shortenPath(makeRelative(params.file_path, this.config.getTargetDir()))}`;
+        displayResult = `Created ${shortenPath(makeRelative(this.params.file_path, this.config.getTargetDir()))}`;
       } else {
         // Generate diff for display, even though core logic doesn't technically need it
         // The CLI wrapper will use this part of the ToolResult
-        const fileName = path.basename(params.file_path);
+        const fileName = path.basename(this.params.file_path);
         const fileDiff = Diff.createPatch(
           fileName,
           editData.currentContent ?? '', // Should not be null here if not isNewFile
@@ -466,12 +363,12 @@ Expectation for required parameters:
 
       const llmSuccessMessageParts = [
         editData.isNewFile
-          ? `Created new file: ${params.file_path} with provided content.`
-          : `Successfully modified file: ${params.file_path} (${editData.occurrences} replacements).`,
+          ? `Created new file: ${this.params.file_path} with provided content.`
+          : `Successfully modified file: ${this.params.file_path} (${editData.occurrences} replacements).`,
       ];
-      if (params.modified_by_user) {
+      if (this.params.modified_by_user) {
         llmSuccessMessageParts.push(
-          `User modified the \`new_string\` content to be: ${params.new_string}.`,
+          `User modified the \`new_string\` content to be: ${this.params.new_string}.`,
         );
       }
 
@@ -501,6 +398,91 @@ Expectation for required parameters:
       fs.mkdirSync(dirName, { recursive: true });
     }
   }
+}
+
+/**
+ * Implementation of the Edit tool logic
+ */
+export class EditTool
+  extends BaseDeclarativeTool<EditToolParams, ToolResult>
+  implements ModifiableDeclarativeTool<EditToolParams>
+{
+  static readonly Name = 'replace';
+  constructor(private readonly config: Config) {
+    super(
+      EditTool.Name,
+      'Edit',
+      `Replaces text within a file. By default, replaces a single occurrence, but can replace multiple occurrences when \`expected_replacements\` is specified. This tool requires providing significant context around the change to ensure precise targeting. Always use the ${ReadFileTool.Name} tool to examine the file's current content before attempting a text replacement.
+
+      The user has the ability to modify the \`new_string\` content. If modified, this will be stated in the response.
+
+Expectation for required parameters:
+1. \`file_path\` MUST be an absolute path; otherwise an error will be thrown.
+2. \`old_string\` MUST be the exact literal text to replace (including all whitespace, indentation, newlines, and surrounding code etc.).
+3. \`new_string\` MUST be the exact literal text to replace \`old_string\` with (also including all whitespace, indentation, newlines, and surrounding code etc.). Ensure the resulting code is correct and idiomatic.
+4. NEVER escape \`old_string\` or \`new_string\`, that would break the exact literal text requirement.
+**Important:** If ANY of the above are not satisfied, the tool will fail. CRITICAL for \`old_string\`: Must uniquely identify the single instance to change. Include at least 3 lines of context BEFORE and AFTER the target text, matching whitespace and indentation precisely. If this string matches multiple locations, or does not match exactly, the tool will fail.
+**Multiple replacements:** Set \`expected_replacements\` to the number of occurrences you want to replace. The tool will replace ALL occurrences that match \`old_string\` exactly. Ensure the number of replacements matches your expectation.`,
+      Icon.Pencil,
+      {
+        properties: {
+          file_path: {
+            description:
+              "The absolute path to the file to modify. Must start with '/'.",
+            type: Type.STRING,
+          },
+          old_string: {
+            description:
+              'The exact literal text to replace, preferably unescaped. For single replacements (default), include at least 3 lines of context BEFORE and AFTER the target text, matching whitespace and indentation precisely. For multiple replacements, specify expected_replacements parameter. If this string is not the exact literal text (i.e. you escaped it) or does not match exactly, the tool will fail.',
+            type: Type.STRING,
+          },
+          new_string: {
+            description:
+              'The exact literal text to replace `old_string` with, preferably unescaped. Provide the EXACT text. Ensure the resulting code is correct and idiomatic.',
+            type: Type.STRING,
+          },
+          expected_replacements: {
+            type: Type.NUMBER,
+            description:
+              'Number of replacements expected. Defaults to 1 if not specified. Use when you want to replace multiple occurrences.',
+            minimum: 1,
+          },
+        },
+        required: ['file_path', 'old_string', 'new_string'],
+        type: Type.OBJECT,
+      },
+    );
+  }
+
+  /**
+   * Validates the parameters for the Edit tool
+   * @param params Parameters to validate
+   * @returns Error message string or null if valid
+   */
+  validateToolParams(params: EditToolParams): string | null {
+    const errors = SchemaValidator.validate(this.schema.parameters, params);
+    if (errors) {
+      return errors;
+    }
+
+    if (!path.isAbsolute(params.file_path)) {
+      return `File path must be absolute: ${params.file_path}`;
+    }
+
+    const workspaceContext = this.config.getWorkspaceContext();
+    if (!workspaceContext.isPathWithinWorkspace(params.file_path)) {
+      const directories = workspaceContext.getDirectories();
+      return `File path must be within one of the workspace directories: ${directories.join(', ')}`;
+    }
+
+    return null;
+  }
+
+  protected createInvocation(
+    params: EditToolParams,
+  ): ToolInvocation<EditToolParams, ToolResult> {
+    return new EditToolInvocation(this.config, params);
+  }
 
   getModifyContext(_: AbortSignal): ModifyContext<EditToolParams> {
     return {
@@ -516,7 +498,7 @@ Expectation for required parameters:
       getProposedContent: async (params: EditToolParams): Promise<string> => {
         try {
           const currentContent = fs.readFileSync(params.file_path, 'utf8');
-          return this._applyReplacement(
+          return applyReplacement(
             currentContent,
             params.old_string,
             params.new_string,
diff --git a/packages/core/src/tools/glob.test.ts b/packages/core/src/tools/glob.test.ts
index 0ee6c0ee..934b7ce7 100644
--- a/packages/core/src/tools/glob.test.ts
+++ b/packages/core/src/tools/glob.test.ts
@@ -64,7 +64,8 @@ describe('GlobTool', () => {
   describe('execute', () => {
     it('should find files matching a simple pattern in the root', async () => {
       const params: GlobToolParams = { pattern: '*.txt' };
-      const result = await globTool.execute(params, abortSignal);
+      const invocation = globTool.build(params);
+      const result = await invocation.execute(abortSignal);
       expect(result.llmContent).toContain('Found 2 file(s)');
       expect(result.llmContent).toContain(path.join(tempRootDir, 'fileA.txt'));
       expect(result.llmContent).toContain(path.join(tempRootDir, 'FileB.TXT'));
@@ -73,7 +74,8 @@ describe('GlobTool', () => {
 
     it('should find files case-sensitively when case_sensitive is true', async () => {
       const params: GlobToolParams = { pattern: '*.txt', case_sensitive: true };
-      const result = await globTool.execute(params, abortSignal);
+      const invocation = globTool.build(params);
+      const result = await invocation.execute(abortSignal);
       expect(result.llmContent).toContain('Found 1 file(s)');
       expect(result.llmContent).toContain(path.join(tempRootDir, 'fileA.txt'));
       expect(result.llmContent).not.toContain(
@@ -83,7 +85,8 @@ describe('GlobTool', () => {
 
     it('should find files case-insensitively by default (pattern: *.TXT)', async () => {
       const params: GlobToolParams = { pattern: '*.TXT' };
-      const result = await globTool.execute(params, abortSignal);
+      const invocation = globTool.build(params);
+      const result = await invocation.execute(abortSignal);
       expect(result.llmContent).toContain('Found 2 file(s)');
       expect(result.llmContent).toContain(path.join(tempRootDir, 'fileA.txt'));
       expect(result.llmContent).toContain(path.join(tempRootDir, 'FileB.TXT'));
@@ -94,7 +97,8 @@ describe('GlobTool', () => {
         pattern: '*.TXT',
         case_sensitive: false,
       };
-      const result = await globTool.execute(params, abortSignal);
+      const invocation = globTool.build(params);
+      const result = await invocation.execute(abortSignal);
       expect(result.llmContent).toContain('Found 2 file(s)');
       expect(result.llmContent).toContain(path.join(tempRootDir, 'fileA.txt'));
       expect(result.llmContent).toContain(path.join(tempRootDir, 'FileB.TXT'));
@@ -102,7 +106,8 @@ describe('GlobTool', () => {
 
     it('should find files using a pattern that includes a subdirectory', async () => {
       const params: GlobToolParams = { pattern: 'sub/*.md' };
-      const result = await globTool.execute(params, abortSignal);
+      const invocation = globTool.build(params);
+      const result = await invocation.execute(abortSignal);
       expect(result.llmContent).toContain('Found 2 file(s)');
       expect(result.llmContent).toContain(
         path.join(tempRootDir, 'sub', 'fileC.md'),
@@ -114,7 +119,8 @@ describe('GlobTool', () => {
 
     it('should find files in a specified relative path (relative to rootDir)', async () => {
       const params: GlobToolParams = { pattern: '*.md', path: 'sub' };
-      const result = await globTool.execute(params, abortSignal);
+      const invocation = globTool.build(params);
+      const result = await invocation.execute(abortSignal);
       expect(result.llmContent).toContain('Found 2 file(s)');
       expect(result.llmContent).toContain(
         path.join(tempRootDir, 'sub', 'fileC.md'),
@@ -126,7 +132,8 @@ describe('GlobTool', () => {
 
     it('should find files using a deep globstar pattern (e.g., **/*.log)', async () => {
       const params: GlobToolParams = { pattern: '**/*.log' };
-      const result = await globTool.execute(params, abortSignal);
+      const invocation = globTool.build(params);
+      const result = await invocation.execute(abortSignal);
       expect(result.llmContent).toContain('Found 1 file(s)');
       expect(result.llmContent).toContain(
         path.join(tempRootDir, 'sub', 'deep', 'fileE.log'),
@@ -135,7 +142,8 @@ describe('GlobTool', () => {
 
     it('should return "No files found" message when pattern matches nothing', async () => {
       const params: GlobToolParams = { pattern: '*.nonexistent' };
-      const result = await globTool.execute(params, abortSignal);
+      const invocation = globTool.build(params);
+      const result = await invocation.execute(abortSignal);
       expect(result.llmContent).toContain(
         'No files found matching pattern "*.nonexistent"',
       );
@@ -144,7 +152,8 @@ describe('GlobTool', () => {
 
     it('should correctly sort files by modification time (newest first)', async () => {
       const params: GlobToolParams = { pattern: '*.sortme' };
-      const result = await globTool.execute(params, abortSignal);
+      const invocation = globTool.build(params);
+      const result = await invocation.execute(abortSignal);
       const llmContent = partListUnionToString(result.llmContent);
 
       expect(llmContent).toContain('Found 2 file(s)');
@@ -242,8 +251,8 @@ describe('GlobTool', () => {
       // Let's try to go further up.
       const paramsOutside: GlobToolParams = {
         pattern: '*.txt',
-        path: '../../../../../../../../../../tmp',
-      }; // Definitely outside
+        path: '../../../../../../../../../../tmp', // Definitely outside
+      };
       expect(specificGlobTool.validateToolParams(paramsOutside)).toContain(
         'resolves outside the allowed workspace directories',
       );
@@ -290,7 +299,8 @@ describe('GlobTool', () => {
 
     it('should work with paths in workspace subdirectories', async () => {
       const params: GlobToolParams = { pattern: '*.md', path: 'sub' };
-      const result = await globTool.execute(params, abortSignal);
+      const invocation = globTool.build(params);
+      const result = await invocation.execute(abortSignal);
 
       expect(result.llmContent).toContain('Found 2 file(s)');
       expect(result.llmContent).toContain('fileC.md');
diff --git a/packages/core/src/tools/glob.ts b/packages/core/src/tools/glob.ts
index 5bcb9778..df0cc348 100644
--- a/packages/core/src/tools/glob.ts
+++ b/packages/core/src/tools/glob.ts
@@ -8,7 +8,13 @@ import fs from 'fs';
 import path from 'path';
 import { glob } from 'glob';
 import { SchemaValidator } from '../utils/schemaValidator.js';
-import { BaseTool, Icon, ToolResult } from './tools.js';
+import {
+  BaseDeclarativeTool,
+  BaseToolInvocation,
+  Icon,
+  ToolInvocation,
+  ToolResult,
+} from './tools.js';
 import { Type } from '@google/genai';
 import { shortenPath, makeRelative } from '../utils/paths.js';
 import { Config } from '../config/config.js';
@@ -74,10 +80,168 @@ export interface GlobToolParams {
   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) {
+        const entries = (await glob(this.params.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 BaseTool<GlobToolParams, ToolResult> {
+export class GlobTool extends BaseDeclarativeTool<GlobToolParams, ToolResult> {
   static readonly Name = 'glob';
 
   constructor(private config: Config) {
@@ -158,166 +322,9 @@ export class GlobTool extends BaseTool<GlobToolParams, ToolResult> {
     return null;
   }
 
-  /**
-   * Gets a description of the glob operation.
-   */
-  getDescription(params: GlobToolParams): string {
-    let description = `'${params.pattern}'`;
-    if (params.path) {
-      const searchDir = path.resolve(
-        this.config.getTargetDir(),
-        params.path || '.',
-      );
-      const relativePath = makeRelative(searchDir, this.config.getTargetDir());
-      description += ` within ${shortenPath(relativePath)}`;
-    }
-    return description;
-  }
-
-  /**
-   * Executes the glob search with the given parameters
-   */
-  async execute(
+  protected createInvocation(
     params: GlobToolParams,
-    signal: AbortSignal,
-  ): Promise<ToolResult> {
-    const validationError = this.validateToolParams(params);
-    if (validationError) {
-      return {
-        llmContent: `Error: Invalid parameters provided. Reason: ${validationError}`,
-        returnDisplay: validationError,
-      };
-    }
-
-    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 (params.path) {
-        const searchDirAbsolute = path.resolve(
-          this.config.getTargetDir(),
-          params.path,
-        );
-        if (!workspaceContext.isPathWithinWorkspace(searchDirAbsolute)) {
-          return {
-            llmContent: `Error: Path "${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 =
-        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) {
-        const entries = (await glob(params.pattern, {
-          cwd: searchDir,
-          withFileTypes: true,
-          nodir: true,
-          stat: true,
-          nocase: !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 "${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 "${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.`,
-      };
-    }
+  ): ToolInvocation<GlobToolParams, ToolResult> {
+    return new GlobToolInvocation(this.config, params);
   }
 }
diff --git a/packages/core/src/tools/grep.test.ts b/packages/core/src/tools/grep.test.ts
index aadc93ae..4bb59115 100644
--- a/packages/core/src/tools/grep.test.ts
+++ b/packages/core/src/tools/grep.test.ts
@@ -120,7 +120,8 @@ describe('GrepTool', () => {
   describe('execute', () => {
     it('should find matches for a simple pattern in all files', async () => {
       const params: GrepToolParams = { pattern: 'world' };
-      const result = await grepTool.execute(params, abortSignal);
+      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',
       );
@@ -136,7 +137,8 @@ describe('GrepTool', () => {
 
     it('should find matches in a specific path', async () => {
       const params: GrepToolParams = { pattern: 'world', path: 'sub' };
-      const result = await grepTool.execute(params, abortSignal);
+      const invocation = grepTool.build(params);
+      const result = await invocation.execute(abortSignal);
       expect(result.llmContent).toContain(
         'Found 1 match for pattern "world" in path "sub"',
       );
@@ -147,7 +149,8 @@ describe('GrepTool', () => {
 
     it('should find matches with an include glob', async () => {
       const params: GrepToolParams = { pattern: 'hello', include: '*.js' };
-      const result = await grepTool.execute(params, abortSignal);
+      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"):',
       );
@@ -168,7 +171,8 @@ describe('GrepTool', () => {
         path: 'sub',
         include: '*.js',
       };
-      const result = await grepTool.execute(params, abortSignal);
+      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")',
       );
@@ -179,7 +183,8 @@ describe('GrepTool', () => {
 
     it('should return "No matches found" when pattern does not exist', async () => {
       const params: GrepToolParams = { pattern: 'nonexistentpattern' };
-      const result = await grepTool.execute(params, abortSignal);
+      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.',
       );
@@ -188,7 +193,8 @@ describe('GrepTool', () => {
 
     it('should handle regex special characters correctly', async () => {
       const params: GrepToolParams = { pattern: 'foo.*bar' }; // Matches 'const foo = "bar";'
-      const result = await grepTool.execute(params, abortSignal);
+      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:',
       );
@@ -198,7 +204,8 @@ describe('GrepTool', () => {
 
     it('should be case-insensitive by default (JS fallback)', async () => {
       const params: GrepToolParams = { pattern: 'HELLO' };
-      const result = await grepTool.execute(params, abortSignal);
+      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:',
       );
@@ -210,14 +217,10 @@ describe('GrepTool', () => {
       );
     });
 
-    it('should return an error if params are invalid', async () => {
+    it('should throw an error if params are invalid', async () => {
       const params = { path: '.' } as unknown as GrepToolParams; // Invalid: pattern missing
-      const result = await grepTool.execute(params, abortSignal);
-      expect(result.llmContent).toBe(
-        "Error: Invalid parameters provided. Reason: params must have required property 'pattern'",
-      );
-      expect(result.returnDisplay).toBe(
-        "Model provided invalid parameters. Error: params must have required property 'pattern'",
+      expect(() => grepTool.build(params)).toThrow(
+        /params must have required property 'pattern'/,
       );
     });
   });
@@ -246,7 +249,8 @@ describe('GrepTool', () => {
 
       const multiDirGrepTool = new GrepTool(multiDirConfig);
       const params: GrepToolParams = { pattern: 'world' };
-      const result = await multiDirGrepTool.execute(params, abortSignal);
+      const invocation = multiDirGrepTool.build(params);
+      const result = await invocation.execute(abortSignal);
 
       // Should find matches in both directories
       expect(result.llmContent).toContain(
@@ -297,7 +301,8 @@ describe('GrepTool', () => {
 
       // Search only in the 'sub' directory of the first workspace
       const params: GrepToolParams = { pattern: 'world', path: 'sub' };
-      const result = await multiDirGrepTool.execute(params, abortSignal);
+      const invocation = multiDirGrepTool.build(params);
+      const result = await invocation.execute(abortSignal);
 
       // Should only find matches in the specified sub directory
       expect(result.llmContent).toContain(
@@ -317,7 +322,8 @@ describe('GrepTool', () => {
   describe('getDescription', () => {
     it('should generate correct description with pattern only', () => {
       const params: GrepToolParams = { pattern: 'testPattern' };
-      expect(grepTool.getDescription(params)).toBe("'testPattern'");
+      const invocation = grepTool.build(params);
+      expect(invocation.getDescription()).toBe("'testPattern'");
     });
 
     it('should generate correct description with pattern and include', () => {
@@ -325,19 +331,21 @@ describe('GrepTool', () => {
         pattern: 'testPattern',
         include: '*.ts',
       };
-      expect(grepTool.getDescription(params)).toBe("'testPattern' in *.ts");
+      const invocation = grepTool.build(params);
+      expect(invocation.getDescription()).toBe("'testPattern' in *.ts");
     });
 
-    it('should generate correct description with pattern and path', () => {
+    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(grepTool.getDescription(params)).toContain("'testPattern' within");
-      expect(grepTool.getDescription(params)).toContain(
-        path.join('src', 'app'),
-      );
+      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', () => {
@@ -350,28 +358,31 @@ describe('GrepTool', () => {
 
       const multiDirGrepTool = new GrepTool(multiDirConfig);
       const params: GrepToolParams = { pattern: 'testPattern' };
-      expect(multiDirGrepTool.getDescription(params)).toBe(
+      const invocation = multiDirGrepTool.build(params);
+      expect(invocation.getDescription()).toBe(
         "'testPattern' across all workspace directories",
       );
     });
 
-    it('should generate correct description with pattern, include, and path', () => {
+    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'),
       };
-      expect(grepTool.getDescription(params)).toContain(
+      const invocation = grepTool.build(params);
+      expect(invocation.getDescription()).toContain(
         "'testPattern' in *.ts within",
       );
-      expect(grepTool.getDescription(params)).toContain(
-        path.join('src', 'app'),
-      );
+      expect(invocation.getDescription()).toContain(path.join('src', 'app'));
     });
 
     it('should use ./ for root path in description', () => {
       const params: GrepToolParams = { pattern: 'testPattern', path: '.' };
-      expect(grepTool.getDescription(params)).toBe("'testPattern' within ./");
+      const invocation = grepTool.build(params);
+      expect(invocation.getDescription()).toBe("'testPattern' within ./");
     });
   });
 });
diff --git a/packages/core/src/tools/grep.ts b/packages/core/src/tools/grep.ts
index 027ab1b1..8e2b84f1 100644
--- a/packages/core/src/tools/grep.ts
+++ b/packages/core/src/tools/grep.ts
@@ -10,7 +10,13 @@ import path from 'path';
 import { EOL } from 'os';
 import { spawn } from 'child_process';
 import { globStream } from 'glob';
-import { BaseTool, Icon, ToolResult } from './tools.js';
+import {
+  BaseDeclarativeTool,
+  BaseToolInvocation,
+  Icon,
+  ToolInvocation,
+  ToolResult,
+} from './tools.js';
 import { Type } from '@google/genai';
 import { SchemaValidator } from '../utils/schemaValidator.js';
 import { makeRelative, shortenPath } from '../utils/paths.js';
@@ -49,46 +55,17 @@ interface GrepMatch {
   line: string;
 }
 
-// --- GrepLogic Class ---
-
-/**
- * Implementation of the Grep tool logic (moved from CLI)
- */
-export class GrepTool extends BaseTool<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.',
-      Icon.Regex,
-      {
-        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: Type.STRING,
-          },
-          path: {
-            description:
-              'Optional: The absolute path to the directory to search within. If omitted, searches the current working directory.',
-            type: 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: Type.STRING,
-          },
-        },
-        required: ['pattern'],
-        type: Type.OBJECT,
-      },
-    );
+class GrepToolInvocation extends BaseToolInvocation<
+  GrepToolParams,
+  ToolResult
+> {
+  constructor(
+    private readonly config: Config,
+    params: GrepToolParams,
+  ) {
+    super(params);
   }
 
-  // --- Validation Methods ---
-
   /**
    * Checks if a path is within the root directory and resolves it.
    * @param relativePath Path relative to the root directory (or undefined for root).
@@ -130,58 +107,11 @@ export class GrepTool extends BaseTool<GrepToolParams, ToolResult> {
     return targetPath;
   }
 
-  /**
-   * Validates the parameters for the tool
-   * @param params Parameters to validate
-   * @returns An error message string if invalid, null otherwise
-   */
-  validateToolParams(params: GrepToolParams): string | null {
-    const errors = SchemaValidator.validate(this.schema.parameters, params);
-    if (errors) {
-      return errors;
-    }
-
-    try {
-      new RegExp(params.pattern);
-    } catch (error) {
-      return `Invalid regular expression pattern provided: ${params.pattern}. Error: ${getErrorMessage(error)}`;
-    }
-
-    // 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
-  }
-
-  // --- Core Execution ---
-
-  /**
-   * Executes the grep search with the given parameters
-   * @param params Parameters for the grep search
-   * @returns Result of the grep search
-   */
-  async execute(
-    params: GrepToolParams,
-    signal: AbortSignal,
-  ): Promise<ToolResult> {
-    const validationError = this.validateToolParams(params);
-    if (validationError) {
-      return {
-        llmContent: `Error: Invalid parameters provided. Reason: ${validationError}`,
-        returnDisplay: `Model provided invalid parameters. Error: ${validationError}`,
-      };
-    }
-
+  async execute(signal: AbortSignal): Promise<ToolResult> {
     try {
       const workspaceContext = this.config.getWorkspaceContext();
-      const searchDirAbs = this.resolveAndValidatePath(params.path);
-      const searchDirDisplay = params.path || '.';
+      const searchDirAbs = this.resolveAndValidatePath(this.params.path);
+      const searchDirDisplay = this.params.path || '.';
 
       // Determine which directories to search
       let searchDirectories: readonly string[];
@@ -197,9 +127,9 @@ export class GrepTool extends BaseTool<GrepToolParams, ToolResult> {
       let allMatches: GrepMatch[] = [];
       for (const searchDir of searchDirectories) {
         const matches = await this.performGrepSearch({
-          pattern: params.pattern,
+          pattern: this.params.pattern,
           path: searchDir,
-          include: params.include,
+          include: this.params.include,
           signal,
         });
 
@@ -226,7 +156,7 @@ export class GrepTool extends BaseTool<GrepToolParams, ToolResult> {
       }
 
       if (allMatches.length === 0) {
-        const noMatchMsg = `No matches found for pattern "${params.pattern}" ${searchLocationDescription}${params.include ? ` (filter: "${params.include}")` : ''}.`;
+        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` };
       }
 
@@ -247,7 +177,7 @@ export class GrepTool extends BaseTool<GrepToolParams, ToolResult> {
       const matchCount = allMatches.length;
       const matchTerm = matchCount === 1 ? 'match' : 'matches';
 
-      let llmContent = `Found ${matchCount} ${matchTerm} for pattern "${params.pattern}" ${searchLocationDescription}${params.include ? ` (filter: "${params.include}")` : ''}:
+      let llmContent = `Found ${matchCount} ${matchTerm} for pattern "${this.params.pattern}" ${searchLocationDescription}${this.params.include ? ` (filter: "${this.params.include}")` : ''}:
 ---
 `;
 
@@ -274,8 +204,6 @@ export class GrepTool extends BaseTool<GrepToolParams, ToolResult> {
     }
   }
 
-  // --- Grep Implementation Logic ---
-
   /**
    * Checks if a command is available in the system's PATH.
    * @param {string} command The command name (e.g., 'git', 'grep').
@@ -353,17 +281,20 @@ export class GrepTool extends BaseTool<GrepToolParams, ToolResult> {
    * @param params Parameters for the grep operation
    * @returns A string describing the grep
    */
-  getDescription(params: GrepToolParams): string {
-    let description = `'${params.pattern}'`;
-    if (params.include) {
-      description += ` in ${params.include}`;
+  getDescription(): string {
+    let description = `'${this.params.pattern}'`;
+    if (this.params.include) {
+      description += ` in ${this.params.include}`;
     }
-    if (params.path) {
+    if (this.params.path) {
       const resolvedPath = path.resolve(
         this.config.getTargetDir(),
-        params.path,
+        this.params.path,
       );
-      if (resolvedPath === this.config.getTargetDir() || params.path === '.') {
+      if (
+        resolvedPath === this.config.getTargetDir() ||
+        this.params.path === '.'
+      ) {
         description += ` within ./`;
       } else {
         const relativePath = makeRelative(
@@ -445,7 +376,9 @@ export class GrepTool extends BaseTool<GrepToolParams, ToolResult> {
           return this.parseGrepOutput(output, absolutePath);
         } catch (gitError: unknown) {
           console.debug(
-            `GrepLogic: git grep failed: ${getErrorMessage(gitError)}. Falling back...`,
+            `GrepLogic: git grep failed: ${getErrorMessage(
+              gitError,
+            )}. Falling back...`,
           );
         }
       }
@@ -525,7 +458,9 @@ export class GrepTool extends BaseTool<GrepToolParams, ToolResult> {
           return this.parseGrepOutput(output, absolutePath);
         } catch (grepError: unknown) {
           console.debug(
-            `GrepLogic: System grep failed: ${getErrorMessage(grepError)}. Falling back...`,
+            `GrepLogic: System grep failed: ${getErrorMessage(
+              grepError,
+            )}. Falling back...`,
           );
         }
       }
@@ -576,7 +511,9 @@ export class GrepTool extends BaseTool<GrepToolParams, ToolResult> {
           // 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)}`,
+              `GrepLogic: Could not read/process ${fileAbsolutePath}: ${getErrorMessage(
+                readError,
+              )}`,
             );
           }
         }
@@ -585,9 +522,126 @@ export class GrepTool extends BaseTool<GrepToolParams, ToolResult> {
       return allMatches;
     } catch (error: unknown) {
       console.error(
-        `GrepLogic: Error in performGrepSearch (Strategy: ${strategyUsed}): ${getErrorMessage(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.',
+      Icon.Regex,
+      {
+        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: Type.STRING,
+          },
+          path: {
+            description:
+              'Optional: The absolute path to the directory to search within. If omitted, searches the current working directory.',
+            type: 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: Type.STRING,
+          },
+        },
+        required: ['pattern'],
+        type: 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
+   */
+  validateToolParams(params: GrepToolParams): string | null {
+    const errors = SchemaValidator.validate(this.schema.parameters, params);
+    if (errors) {
+      return errors;
+    }
+
+    try {
+      new RegExp(params.pattern);
+    } catch (error) {
+      return `Invalid regular expression pattern provided: ${params.pattern}. Error: ${getErrorMessage(error)}`;
+    }
+
+    // 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);
+  }
+}
diff --git a/packages/core/src/tools/read-file.ts b/packages/core/src/tools/read-file.ts
index 7ef9d2b5..4c1d044c 100644
--- a/packages/core/src/tools/read-file.ts
+++ b/packages/core/src/tools/read-file.ts
@@ -9,6 +9,7 @@ import { SchemaValidator } from '../utils/schemaValidator.js';
 import { makeRelative, shortenPath } from '../utils/paths.js';
 import {
   BaseDeclarativeTool,
+  BaseToolInvocation,
   Icon,
   ToolInvocation,
   ToolLocation,
@@ -45,13 +46,16 @@ export interface ReadFileToolParams {
   limit?: number;
 }
 
-class ReadFileToolInvocation
-  implements ToolInvocation<ReadFileToolParams, ToolResult>
-{
+class ReadFileToolInvocation extends BaseToolInvocation<
+  ReadFileToolParams,
+  ToolResult
+> {
   constructor(
     private config: Config,
-    public params: ReadFileToolParams,
-  ) {}
+    params: ReadFileToolParams,
+  ) {
+    super(params);
+  }
 
   getDescription(): string {
     const relativePath = makeRelative(
@@ -61,14 +65,10 @@ class ReadFileToolInvocation
     return shortenPath(relativePath);
   }
 
-  toolLocations(): ToolLocation[] {
+  override toolLocations(): ToolLocation[] {
     return [{ path: this.params.absolute_path, line: this.params.offset }];
   }
 
-  shouldConfirmExecute(): Promise<false> {
-    return Promise.resolve(false);
-  }
-
   async execute(): Promise<ToolResult> {
     const result = await processSingleFileContent(
       this.params.absolute_path,
diff --git a/packages/core/src/tools/tools.ts b/packages/core/src/tools/tools.ts
index 79e6f010..ceacd6ca 100644
--- a/packages/core/src/tools/tools.ts
+++ b/packages/core/src/tools/tools.ts
@@ -53,6 +53,34 @@ export interface ToolInvocation<
   ): Promise<TResult>;
 }
 
+/**
+ * A convenience base class for ToolInvocation.
+ */
+export abstract class BaseToolInvocation<
+  TParams extends object,
+  TResult extends ToolResult,
+> implements ToolInvocation<TParams, TResult>
+{
+  constructor(readonly params: TParams) {}
+
+  abstract getDescription(): string;
+
+  toolLocations(): ToolLocation[] {
+    return [];
+  }
+
+  shouldConfirmExecute(
+    _abortSignal: AbortSignal,
+  ): Promise<ToolCallConfirmationDetails | false> {
+    return Promise.resolve(false);
+  }
+
+  abstract execute(
+    signal: AbortSignal,
+    updateOutput?: (output: string) => void,
+  ): Promise<TResult>;
+}
+
 /**
  * A type alias for a tool invocation where the specific parameter and result types are not known.
  */

From 7596481a9d537715ce74309b2b3da85d192d059a Mon Sep 17 00:00:00 2001
From: Shehab <127568346+dizzydroid@users.noreply.github.com>
Date: Thu, 7 Aug 2025 20:26:55 +0300
Subject: [PATCH 037/107] feat(cli): Allow Exiting Authentication Menu with
 CTRL+C (SIGINT) (#4482)

Co-authored-by: Seth Troisi <sethtroisi@google.com>
---
 packages/cli/src/ui/App.tsx                       | 4 ++++
 packages/cli/src/ui/components/AuthInProgress.tsx | 7 ++++---
 2 files changed, 8 insertions(+), 3 deletions(-)

diff --git a/packages/cli/src/ui/App.tsx b/packages/cli/src/ui/App.tsx
index 2be681e5..d311facf 100644
--- a/packages/cli/src/ui/App.tsx
+++ b/packages/cli/src/ui/App.tsx
@@ -632,6 +632,10 @@ const App = ({ config, settings, startupWarnings = [], version }: AppProps) => {
     ) {
       setShowIDEContextDetail((prev) => !prev);
     } else if (key.ctrl && (input === 'c' || input === 'C')) {
+      if (isAuthenticating) {
+        // Let AuthInProgress component handle the input.
+        return;
+      }
       handleExit(ctrlCPressedOnce, setCtrlCPressedOnce, ctrlCTimerRef);
     } else if (key.ctrl && (input === 'd' || input === 'D')) {
       if (buffer.text.length > 0) {
diff --git a/packages/cli/src/ui/components/AuthInProgress.tsx b/packages/cli/src/ui/components/AuthInProgress.tsx
index 196097f2..f05efe1d 100644
--- a/packages/cli/src/ui/components/AuthInProgress.tsx
+++ b/packages/cli/src/ui/components/AuthInProgress.tsx
@@ -18,8 +18,8 @@ export function AuthInProgress({
 }: AuthInProgressProps): React.JSX.Element {
   const [timedOut, setTimedOut] = useState(false);
 
-  useInput((_, key) => {
-    if (key.escape) {
+  useInput((input, key) => {
+    if (key.escape || (key.ctrl && (input === 'c' || input === 'C'))) {
       onTimeout();
     }
   });
@@ -48,7 +48,8 @@ export function AuthInProgress({
       ) : (
         <Box>
           <Text>
-            <Spinner type="dots" /> Waiting for auth... (Press ESC to cancel)
+            <Spinner type="dots" /> Waiting for auth... (Press ESC or CTRL+C to
+            cancel)
           </Text>
         </Box>
       )}

From a3351bc9854584d24eca24fe8bc5b867e1fe3b03 Mon Sep 17 00:00:00 2001
From: anthony bushong <agmsb@users.noreply.github.com>
Date: Thu, 7 Aug 2025 10:58:44 -0700
Subject: [PATCH 038/107] fix(tests): add missing deps in cli to fix sandbox
 runs (#5742)

---
 package-lock.json         | 2 ++
 packages/cli/package.json | 2 ++
 2 files changed, 4 insertions(+)

diff --git a/package-lock.json b/package-lock.json
index 1e5e4211..e254cab8 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -11681,6 +11681,7 @@
         "@google/gemini-cli-core": "file:../core",
         "@google/genai": "1.9.0",
         "@iarna/toml": "^2.2.5",
+        "@modelcontextprotocol/sdk": "^1.15.1",
         "@types/update-notifier": "^6.0.8",
         "command-exists": "^1.2.9",
         "diff": "^7.0.0",
@@ -11702,6 +11703,7 @@
         "string-width": "^7.1.0",
         "strip-ansi": "^7.1.0",
         "strip-json-comments": "^3.1.1",
+        "undici": "^7.10.0",
         "update-notifier": "^7.3.1",
         "yargs": "^17.7.2",
         "zod": "^3.23.8"
diff --git a/packages/cli/package.json b/packages/cli/package.json
index ca64f6f7..59d1cbf2 100644
--- a/packages/cli/package.json
+++ b/packages/cli/package.json
@@ -31,6 +31,7 @@
     "@google/gemini-cli-core": "file:../core",
     "@google/genai": "1.9.0",
     "@iarna/toml": "^2.2.5",
+    "@modelcontextprotocol/sdk": "^1.15.1",
     "@types/update-notifier": "^6.0.8",
     "command-exists": "^1.2.9",
     "diff": "^7.0.0",
@@ -52,6 +53,7 @@
     "string-width": "^7.1.0",
     "strip-ansi": "^7.1.0",
     "strip-json-comments": "^3.1.1",
+    "undici": "^7.10.0",
     "update-notifier": "^7.3.1",
     "yargs": "^17.7.2",
     "zod": "^3.23.8"

From 8e6a565adbec90d2216fbc2e06d10bf9f0c0c1bf Mon Sep 17 00:00:00 2001
From: Pyush Sinha <pyushsinha20@gmail.com>
Date: Thu, 7 Aug 2025 11:16:47 -0700
Subject: [PATCH 039/107] fix: re render context usage indicator  (#5102)

---
 .../src/ui/components/ContextUsageDisplay.tsx |  25 +++
 packages/cli/src/ui/components/Footer.tsx     | 158 +++++++++---------
 2 files changed, 102 insertions(+), 81 deletions(-)
 create mode 100644 packages/cli/src/ui/components/ContextUsageDisplay.tsx

diff --git a/packages/cli/src/ui/components/ContextUsageDisplay.tsx b/packages/cli/src/ui/components/ContextUsageDisplay.tsx
new file mode 100644
index 00000000..037be333
--- /dev/null
+++ b/packages/cli/src/ui/components/ContextUsageDisplay.tsx
@@ -0,0 +1,25 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { Text } from 'ink';
+import { Colors } from '../colors.js';
+import { tokenLimit } from '@google/gemini-cli-core';
+
+export const ContextUsageDisplay = ({
+  promptTokenCount,
+  model,
+}: {
+  promptTokenCount: number;
+  model: string;
+}) => {
+  const percentage = promptTokenCount / tokenLimit(model);
+
+  return (
+    <Text color={Colors.Gray}>
+      ({((1 - percentage) * 100).toFixed(0)}% context left)
+    </Text>
+  );
+};
diff --git a/packages/cli/src/ui/components/Footer.tsx b/packages/cli/src/ui/components/Footer.tsx
index acc55870..14cda5f3 100644
--- a/packages/cli/src/ui/components/Footer.tsx
+++ b/packages/cli/src/ui/components/Footer.tsx
@@ -7,12 +7,12 @@
 import React from 'react';
 import { Box, Text } from 'ink';
 import { Colors } from '../colors.js';
-import { shortenPath, tildeifyPath, tokenLimit } from '@google/gemini-cli-core';
+import { shortenPath, tildeifyPath } from '@google/gemini-cli-core';
 import { ConsoleSummaryDisplay } from './ConsoleSummaryDisplay.js';
 import process from 'node:process';
 import Gradient from 'ink-gradient';
 import { MemoryUsageDisplay } from './MemoryUsageDisplay.js';
-
+import { ContextUsageDisplay } from './ContextUsageDisplay.js';
 import { DebugProfiler } from './DebugProfiler.js';
 
 interface FooterProps {
@@ -43,85 +43,81 @@ export const Footer: React.FC<FooterProps> = ({
   promptTokenCount,
   nightly,
   vimMode,
-}) => {
-  const limit = tokenLimit(model);
-  const percentage = promptTokenCount / limit;
-
-  return (
-    <Box justifyContent="space-between" width="100%">
-      <Box>
-        {debugMode && <DebugProfiler />}
-        {vimMode && <Text color={Colors.Gray}>[{vimMode}] </Text>}
-        {nightly ? (
-          <Gradient colors={Colors.GradientColors}>
-            <Text>
-              {shortenPath(tildeifyPath(targetDir), 70)}
-              {branchName && <Text> ({branchName}*)</Text>}
-            </Text>
-          </Gradient>
-        ) : (
-          <Text color={Colors.LightBlue}>
-            {shortenPath(tildeifyPath(targetDir), 70)}
-            {branchName && <Text color={Colors.Gray}> ({branchName}*)</Text>}
-          </Text>
-        )}
-        {debugMode && (
-          <Text color={Colors.AccentRed}>
-            {' ' + (debugMessage || '--debug')}
-          </Text>
-        )}
-      </Box>
-
-      {/* Middle Section: Centered Sandbox Info */}
-      <Box
-        flexGrow={1}
-        alignItems="center"
-        justifyContent="center"
-        display="flex"
-      >
-        {process.env.SANDBOX && process.env.SANDBOX !== 'sandbox-exec' ? (
-          <Text color="green">
-            {process.env.SANDBOX.replace(/^gemini-(?:cli-)?/, '')}
-          </Text>
-        ) : process.env.SANDBOX === 'sandbox-exec' ? (
-          <Text color={Colors.AccentYellow}>
-            macOS Seatbelt{' '}
-            <Text color={Colors.Gray}>({process.env.SEATBELT_PROFILE})</Text>
-          </Text>
-        ) : (
-          <Text color={Colors.AccentRed}>
-            no sandbox <Text color={Colors.Gray}>(see /docs)</Text>
-          </Text>
-        )}
-      </Box>
-
-      {/* Right Section: Gemini Label and Console Summary */}
-      <Box alignItems="center">
-        <Text color={Colors.AccentBlue}>
-          {' '}
-          {model}{' '}
-          <Text color={Colors.Gray}>
-            ({((1 - percentage) * 100).toFixed(0)}% context left)
-          </Text>
-        </Text>
-        {corgiMode && (
+}) => (
+  <Box justifyContent="space-between" width="100%">
+    <Box>
+      {debugMode && <DebugProfiler />}
+      {vimMode && <Text color={Colors.Gray}>[{vimMode}] </Text>}
+      {nightly ? (
+        <Gradient colors={Colors.GradientColors}>
           <Text>
-            <Text color={Colors.Gray}>| </Text>
-            <Text color={Colors.AccentRed}>▼</Text>
-            <Text color={Colors.Foreground}>(´</Text>
-            <Text color={Colors.AccentRed}>ᴥ</Text>
-            <Text color={Colors.Foreground}>`)</Text>
-            <Text color={Colors.AccentRed}>▼ </Text>
+            {shortenPath(tildeifyPath(targetDir), 70)}
+            {branchName && <Text> ({branchName}*)</Text>}
           </Text>
-        )}
-        {!showErrorDetails && errorCount > 0 && (
-          <Box>
-            <Text color={Colors.Gray}>| </Text>
-            <ConsoleSummaryDisplay errorCount={errorCount} />
-          </Box>
-        )}
-        {showMemoryUsage && <MemoryUsageDisplay />}
-      </Box>
+        </Gradient>
+      ) : (
+        <Text color={Colors.LightBlue}>
+          {shortenPath(tildeifyPath(targetDir), 70)}
+          {branchName && <Text color={Colors.Gray}> ({branchName}*)</Text>}
+        </Text>
+      )}
+      {debugMode && (
+        <Text color={Colors.AccentRed}>
+          {' ' + (debugMessage || '--debug')}
+        </Text>
+      )}
     </Box>
-  );
-};
+
+    {/* Middle Section: Centered Sandbox Info */}
+    <Box
+      flexGrow={1}
+      alignItems="center"
+      justifyContent="center"
+      display="flex"
+    >
+      {process.env.SANDBOX && process.env.SANDBOX !== 'sandbox-exec' ? (
+        <Text color="green">
+          {process.env.SANDBOX.replace(/^gemini-(?:cli-)?/, '')}
+        </Text>
+      ) : process.env.SANDBOX === 'sandbox-exec' ? (
+        <Text color={Colors.AccentYellow}>
+          macOS Seatbelt{' '}
+          <Text color={Colors.Gray}>({process.env.SEATBELT_PROFILE})</Text>
+        </Text>
+      ) : (
+        <Text color={Colors.AccentRed}>
+          no sandbox <Text color={Colors.Gray}>(see /docs)</Text>
+        </Text>
+      )}
+    </Box>
+
+    {/* Right Section: Gemini Label and Console Summary */}
+    <Box alignItems="center">
+      <Text color={Colors.AccentBlue}>
+        {' '}
+        {model}{' '}
+        <ContextUsageDisplay
+          promptTokenCount={promptTokenCount}
+          model={model}
+        />
+      </Text>
+      {corgiMode && (
+        <Text>
+          <Text color={Colors.Gray}>| </Text>
+          <Text color={Colors.AccentRed}>▼</Text>
+          <Text color={Colors.Foreground}>(´</Text>
+          <Text color={Colors.AccentRed}>ᴥ</Text>
+          <Text color={Colors.Foreground}>`)</Text>
+          <Text color={Colors.AccentRed}>▼ </Text>
+        </Text>
+      )}
+      {!showErrorDetails && errorCount > 0 && (
+        <Box>
+          <Text color={Colors.Gray}>| </Text>
+          <ConsoleSummaryDisplay errorCount={errorCount} />
+        </Box>
+      )}
+      {showMemoryUsage && <MemoryUsageDisplay />}
+    </Box>
+  </Box>
+);

From 3a3b1381950fb3aab09f71e0ad1662a4f77b3c43 Mon Sep 17 00:00:00 2001
From: Adam Weidman <65992621+adamfweidman@users.noreply.github.com>
Date: Thu, 7 Aug 2025 20:21:39 +0000
Subject: [PATCH 040/107] Include Schema Error Handling for Vertex and Google
 Auth methods (#5780)

Co-authored-by: Jacob Richman <jacob314@gmail.com>
---
 packages/core/src/core/geminiChat.ts | 61 +++++++++++++++-------------
 packages/core/src/core/turn.test.ts  |  6 ++-
 packages/core/src/core/turn.ts       |  1 +
 3 files changed, 39 insertions(+), 29 deletions(-)

diff --git a/packages/core/src/core/geminiChat.ts b/packages/core/src/core/geminiChat.ts
index cff23d2d..085bc993 100644
--- a/packages/core/src/core/geminiChat.ts
+++ b/packages/core/src/core/geminiChat.ts
@@ -33,7 +33,7 @@ import {
 } from '../telemetry/types.js';
 import { DEFAULT_GEMINI_FLASH_MODEL } from '../config/models.js';
 import { hasCycleInSchema } from '../tools/tools.js';
-import { isStructuredError } from '../utils/quotaErrorDetection.js';
+import { StructuredError } from './turn.js';
 
 /**
  * Returns true if the response is valid, false otherwise.
@@ -352,7 +352,6 @@ export class GeminiChat {
     } catch (error) {
       const durationMs = Date.now() - startTime;
       this._logApiError(durationMs, error, prompt_id);
-      await this.maybeIncludeSchemaDepthContext(error);
       this.sendPromise = Promise.resolve();
       throw error;
     }
@@ -452,7 +451,6 @@ export class GeminiChat {
       const durationMs = Date.now() - startTime;
       this._logApiError(durationMs, error, prompt_id);
       this.sendPromise = Promise.resolve();
-      await this.maybeIncludeSchemaDepthContext(error);
       throw error;
     }
   }
@@ -523,6 +521,34 @@ export class GeminiChat {
     return lastChunkWithMetadata?.usageMetadata;
   }
 
+  async maybeIncludeSchemaDepthContext(error: StructuredError): Promise<void> {
+    // Check for potentially problematic cyclic tools with cyclic schemas
+    // and include a recommendation to remove potentially problematic tools.
+    if (
+      isSchemaDepthError(error.message) ||
+      isInvalidArgumentError(error.message)
+    ) {
+      const tools = (await this.config.getToolRegistry()).getAllTools();
+      const cyclicSchemaTools: string[] = [];
+      for (const tool of tools) {
+        if (
+          (tool.schema.parametersJsonSchema &&
+            hasCycleInSchema(tool.schema.parametersJsonSchema)) ||
+          (tool.schema.parameters && hasCycleInSchema(tool.schema.parameters))
+        ) {
+          cyclicSchemaTools.push(tool.displayName);
+        }
+      }
+      if (cyclicSchemaTools.length > 0) {
+        const extraDetails =
+          `\n\nThis error was probably caused by cyclic schema references in one of the following tools, try disabling them with excludeTools:\n\n - ` +
+          cyclicSchemaTools.join(`\n - `) +
+          `\n`;
+        error.message += extraDetails;
+      }
+    }
+  }
+
   private async *processStreamResponse(
     streamResponse: AsyncGenerator<GenerateContentResponse>,
     inputContent: Content,
@@ -684,34 +710,13 @@ export class GeminiChat {
       content.parts[0].thought === true
     );
   }
-
-  private async maybeIncludeSchemaDepthContext(error: unknown): Promise<void> {
-    // Check for potentially problematic cyclic tools with cyclic schemas
-    // and include a recommendation to remove potentially problematic tools.
-    if (isStructuredError(error) && isSchemaDepthError(error.message)) {
-      const tools = (await this.config.getToolRegistry()).getAllTools();
-      const cyclicSchemaTools: string[] = [];
-      for (const tool of tools) {
-        if (
-          (tool.schema.parametersJsonSchema &&
-            hasCycleInSchema(tool.schema.parametersJsonSchema)) ||
-          (tool.schema.parameters && hasCycleInSchema(tool.schema.parameters))
-        ) {
-          cyclicSchemaTools.push(tool.displayName);
-        }
-      }
-      if (cyclicSchemaTools.length > 0) {
-        const extraDetails =
-          `\n\nThis error was probably caused by cyclic schema references in one of the following tools, try disabling them:\n\n - ` +
-          cyclicSchemaTools.join(`\n - `) +
-          `\n`;
-        error.message += extraDetails;
-      }
-    }
-  }
 }
 
 /** Visible for Testing */
 export function isSchemaDepthError(errorMessage: string): boolean {
   return errorMessage.includes('maximum schema depth exceeded');
 }
+
+export function isInvalidArgumentError(errorMessage: string): boolean {
+  return errorMessage.includes('Request contains an invalid argument');
+}
diff --git a/packages/core/src/core/turn.test.ts b/packages/core/src/core/turn.test.ts
index 2a557927..7144d16b 100644
--- a/packages/core/src/core/turn.test.ts
+++ b/packages/core/src/core/turn.test.ts
@@ -17,12 +17,14 @@ import { GeminiChat } from './geminiChat.js';
 
 const mockSendMessageStream = vi.fn();
 const mockGetHistory = vi.fn();
+const mockMaybeIncludeSchemaDepthContext = vi.fn();
 
 vi.mock('@google/genai', async (importOriginal) => {
   const actual = await importOriginal<typeof import('@google/genai')>();
   const MockChat = vi.fn().mockImplementation(() => ({
     sendMessageStream: mockSendMessageStream,
     getHistory: mockGetHistory,
+    maybeIncludeSchemaDepthContext: mockMaybeIncludeSchemaDepthContext,
   }));
   return {
     ...actual,
@@ -46,6 +48,7 @@ describe('Turn', () => {
   type MockedChatInstance = {
     sendMessageStream: typeof mockSendMessageStream;
     getHistory: typeof mockGetHistory;
+    maybeIncludeSchemaDepthContext: typeof mockMaybeIncludeSchemaDepthContext;
   };
   let mockChatInstance: MockedChatInstance;
 
@@ -54,6 +57,7 @@ describe('Turn', () => {
     mockChatInstance = {
       sendMessageStream: mockSendMessageStream,
       getHistory: mockGetHistory,
+      maybeIncludeSchemaDepthContext: mockMaybeIncludeSchemaDepthContext,
     };
     turn = new Turn(mockChatInstance as unknown as GeminiChat, 'prompt-id-1');
     mockGetHistory.mockReturnValue([]);
@@ -200,7 +204,7 @@ describe('Turn', () => {
         { role: 'model', parts: [{ text: 'Previous history' }] },
       ];
       mockGetHistory.mockReturnValue(historyContent);
-
+      mockMaybeIncludeSchemaDepthContext.mockResolvedValue(undefined);
       const events = [];
       for await (const event of turn.run(
         reqParts,
diff --git a/packages/core/src/core/turn.ts b/packages/core/src/core/turn.ts
index ee32c309..8ede1fa4 100644
--- a/packages/core/src/core/turn.ts
+++ b/packages/core/src/core/turn.ts
@@ -275,6 +275,7 @@ export class Turn {
         message: getErrorMessage(error),
         status,
       };
+      await this.chat.maybeIncludeSchemaDepthContext(structuredError);
       yield { type: GeminiEventType.Error, value: { error: structuredError } };
       return;
     }

From 53f8617b249c9f0443f5082a293a30504a118030 Mon Sep 17 00:00:00 2001
From: shrutip90 <shruti.p90@gmail.com>
Date: Thu, 7 Aug 2025 14:06:17 -0700
Subject: [PATCH 041/107] Add new folderTrust setting that the users can enable
 or disable (#5798)

---
 packages/cli/src/config/config.test.ts   | 52 ++++++++++++++++++++++
 packages/cli/src/config/config.ts        |  3 ++
 packages/cli/src/config/settings.test.ts | 56 ++++++++++++++++++++++++
 packages/cli/src/config/settings.ts      | 12 ++++-
 packages/core/src/config/config.ts       | 11 ++++-
 5 files changed, 130 insertions(+), 4 deletions(-)

diff --git a/packages/cli/src/config/config.test.ts b/packages/cli/src/config/config.test.ts
index b670fbc8..1d83ccbc 100644
--- a/packages/cli/src/config/config.test.ts
+++ b/packages/cli/src/config/config.test.ts
@@ -1042,6 +1042,58 @@ describe('loadCliConfig folderTrustFeature', () => {
   });
 });
 
+describe('loadCliConfig folderTrust', () => {
+  const originalArgv = process.argv;
+  const originalEnv = { ...process.env };
+
+  beforeEach(() => {
+    vi.resetAllMocks();
+    vi.mocked(os.homedir).mockReturnValue('/mock/home/user');
+    process.env.GEMINI_API_KEY = 'test-api-key';
+  });
+
+  afterEach(() => {
+    process.argv = originalArgv;
+    process.env = originalEnv;
+    vi.restoreAllMocks();
+  });
+
+  it('should be false if folderTrustFeature is false and folderTrust is false', async () => {
+    process.argv = ['node', 'script.js'];
+    const settings: Settings = {
+      folderTrustFeature: false,
+      folderTrust: false,
+    };
+    const argv = await parseArguments();
+    const config = await loadCliConfig(settings, [], 'test-session', argv);
+    expect(config.getFolderTrust()).toBe(false);
+  });
+
+  it('should be false if folderTrustFeature is true and folderTrust is false', async () => {
+    process.argv = ['node', 'script.js'];
+    const argv = await parseArguments();
+    const settings: Settings = { folderTrustFeature: true, folderTrust: false };
+    const config = await loadCliConfig(settings, [], 'test-session', argv);
+    expect(config.getFolderTrust()).toBe(false);
+  });
+
+  it('should be false if folderTrustFeature is false and folderTrust is true', async () => {
+    process.argv = ['node', 'script.js'];
+    const argv = await parseArguments();
+    const settings: Settings = { folderTrustFeature: false, folderTrust: true };
+    const config = await loadCliConfig(settings, [], 'test-session', argv);
+    expect(config.getFolderTrust()).toBe(false);
+  });
+
+  it('should be true when folderTrustFeature is true and folderTrust is true', async () => {
+    process.argv = ['node', 'script.js'];
+    const argv = await parseArguments();
+    const settings: Settings = { folderTrustFeature: true, folderTrust: true };
+    const config = await loadCliConfig(settings, [], 'test-session', argv);
+    expect(config.getFolderTrust()).toBe(true);
+  });
+});
+
 vi.mock('fs', async () => {
   const actualFs = await vi.importActual<typeof fs>('fs');
   const MOCK_CWD1 = process.cwd();
diff --git a/packages/cli/src/config/config.ts b/packages/cli/src/config/config.ts
index a47d8301..3104e4c1 100644
--- a/packages/cli/src/config/config.ts
+++ b/packages/cli/src/config/config.ts
@@ -314,6 +314,8 @@ export async function loadCliConfig(
     argv.ideModeFeature ?? settings.ideModeFeature ?? false;
 
   const folderTrustFeature = settings.folderTrustFeature ?? false;
+  const folderTrustSetting = settings.folderTrust ?? false;
+  const folderTrust = folderTrustFeature && folderTrustSetting;
 
   const allExtensions = annotateActiveExtensions(
     extensions,
@@ -484,6 +486,7 @@ export async function loadCliConfig(
     ideModeFeature,
     chatCompression: settings.chatCompression,
     folderTrustFeature,
+    folderTrust,
   });
 }
 
diff --git a/packages/cli/src/config/settings.test.ts b/packages/cli/src/config/settings.test.ts
index f68b13e3..353a5783 100644
--- a/packages/cli/src/config/settings.test.ts
+++ b/packages/cli/src/config/settings.test.ts
@@ -310,6 +310,62 @@ describe('Settings Loading and Merging', () => {
       });
     });
 
+    it('should ignore folderTrust from workspace settings', () => {
+      (mockFsExistsSync as Mock).mockReturnValue(true);
+      const userSettingsContent = {
+        folderTrust: true,
+      };
+      const workspaceSettingsContent = {
+        folderTrust: false, // This should be ignored
+      };
+      const systemSettingsContent = {
+        // No folderTrust here
+      };
+
+      (fs.readFileSync as Mock).mockImplementation(
+        (p: fs.PathOrFileDescriptor) => {
+          if (p === getSystemSettingsPath())
+            return JSON.stringify(systemSettingsContent);
+          if (p === USER_SETTINGS_PATH)
+            return JSON.stringify(userSettingsContent);
+          if (p === MOCK_WORKSPACE_SETTINGS_PATH)
+            return JSON.stringify(workspaceSettingsContent);
+          return '{}';
+        },
+      );
+
+      const settings = loadSettings(MOCK_WORKSPACE_DIR);
+      expect(settings.merged.folderTrust).toBe(true); // User setting should be used
+    });
+
+    it('should use system folderTrust over user setting', () => {
+      (mockFsExistsSync as Mock).mockReturnValue(true);
+      const userSettingsContent = {
+        folderTrust: false,
+      };
+      const workspaceSettingsContent = {
+        folderTrust: true, // This should be ignored
+      };
+      const systemSettingsContent = {
+        folderTrust: true,
+      };
+
+      (fs.readFileSync as Mock).mockImplementation(
+        (p: fs.PathOrFileDescriptor) => {
+          if (p === getSystemSettingsPath())
+            return JSON.stringify(systemSettingsContent);
+          if (p === USER_SETTINGS_PATH)
+            return JSON.stringify(userSettingsContent);
+          if (p === MOCK_WORKSPACE_SETTINGS_PATH)
+            return JSON.stringify(workspaceSettingsContent);
+          return '{}';
+        },
+      );
+
+      const settings = loadSettings(MOCK_WORKSPACE_DIR);
+      expect(settings.merged.folderTrust).toBe(true); // System setting should be used
+    });
+
     it('should handle contextFileName correctly when only in user settings', () => {
       (mockFsExistsSync as Mock).mockImplementation(
         (p: fs.PathLike) => p === USER_SETTINGS_PATH,
diff --git a/packages/cli/src/config/settings.ts b/packages/cli/src/config/settings.ts
index 8005ad65..a3bd8d47 100644
--- a/packages/cli/src/config/settings.ts
+++ b/packages/cli/src/config/settings.ts
@@ -113,10 +113,14 @@ export interface Settings {
 
   // Flag to be removed post-launch.
   ideModeFeature?: boolean;
-  folderTrustFeature?: boolean;
   /// IDE mode setting configured via slash command toggle.
   ideMode?: boolean;
 
+  // Flag to be removed post-launch.
+  folderTrustFeature?: boolean;
+  // Setting to track whether Folder trust is enabled.
+  folderTrust?: boolean;
+
   // Setting to track if the user has seen the IDE integration nudge.
   hasSeenIdeIntegrationNudge?: boolean;
 
@@ -178,9 +182,13 @@ export class LoadedSettings {
     const user = this.user.settings;
     const workspace = this.workspace.settings;
 
+    // folderTrust is not supported at workspace level.
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    const { folderTrust, ...workspaceWithoutFolderTrust } = workspace;
+
     return {
       ...user,
-      ...workspace,
+      ...workspaceWithoutFolderTrust,
       ...system,
       customThemes: {
         ...(user.customThemes || {}),
diff --git a/packages/core/src/config/config.ts b/packages/core/src/config/config.ts
index 4848bfb6..db226c76 100644
--- a/packages/core/src/config/config.ts
+++ b/packages/core/src/config/config.ts
@@ -193,6 +193,7 @@ export interface ConfigParameters {
   summarizeToolOutput?: Record<string, SummarizeToolOutputSettings>;
   ideModeFeature?: boolean;
   folderTrustFeature?: boolean;
+  folderTrust?: boolean;
   ideMode?: boolean;
   loadMemoryFromIncludeDirectories?: boolean;
   chatCompression?: ChatCompressionSettings;
@@ -240,6 +241,7 @@ export class Config {
   private readonly noBrowser: boolean;
   private readonly ideModeFeature: boolean;
   private readonly folderTrustFeature: boolean;
+  private readonly folderTrust: boolean;
   private ideMode: boolean;
   private ideClient: IdeClient;
   private inFallbackMode = false;
@@ -314,6 +316,7 @@ export class Config {
     this.summarizeToolOutput = params.summarizeToolOutput;
     this.ideModeFeature = params.ideModeFeature ?? false;
     this.folderTrustFeature = params.folderTrustFeature ?? false;
+    this.folderTrust = params.folderTrust ?? false;
     this.ideMode = params.ideMode ?? false;
     this.ideClient = IdeClient.getInstance();
     if (this.ideMode && this.ideModeFeature) {
@@ -648,12 +651,16 @@ export class Config {
     return this.ideModeFeature;
   }
 
+  getIdeMode(): boolean {
+    return this.ideMode;
+  }
+
   getFolderTrustFeature(): boolean {
     return this.folderTrustFeature;
   }
 
-  getIdeMode(): boolean {
-    return this.ideMode;
+  getFolderTrust(): boolean {
+    return this.folderTrust;
   }
 
   setIdeMode(value: boolean): void {

From 19491b7b940912c2fb3fe24b2f189d3fd5668669 Mon Sep 17 00:00:00 2001
From: Jacob MacDonald <jakemac@google.com>
Date: Thu, 7 Aug 2025 14:19:06 -0700
Subject: [PATCH 042/107] avoid loading and initializing CLI config twice in
 non-interactive mode (#5793)

---
 packages/cli/src/config/config.test.ts  | 142 +++++++++++++++++++++++-
 packages/cli/src/config/config.ts       |  31 +++++-
 packages/cli/src/gemini.tsx             |  61 +---------
 packages/cli/src/nonInteractiveCli.ts   |   1 -
 packages/core/src/config/config.test.ts |  12 ++
 packages/core/src/config/config.ts      |  15 +++
 6 files changed, 201 insertions(+), 61 deletions(-)

diff --git a/packages/cli/src/config/config.test.ts b/packages/cli/src/config/config.test.ts
index 1d83ccbc..701ae267 100644
--- a/packages/cli/src/config/config.test.ts
+++ b/packages/cli/src/config/config.test.ts
@@ -8,6 +8,7 @@ import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
 import * as os from 'os';
 import * as fs from 'fs';
 import * as path from 'path';
+import { ShellTool, EditTool, WriteFileTool } from '@google/gemini-cli-core';
 import { loadCliConfig, parseArguments } from './config.js';
 import { Settings } from './settings.js';
 import { Extension } from './extension.js';
@@ -561,6 +562,17 @@ describe('mergeMcpServers', () => {
 });
 
 describe('mergeExcludeTools', () => {
+  const defaultExcludes = [ShellTool.Name, EditTool.Name, WriteFileTool.Name];
+  const originalIsTTY = process.stdin.isTTY;
+
+  beforeEach(() => {
+    process.stdin.isTTY = true;
+  });
+
+  afterEach(() => {
+    process.stdin.isTTY = originalIsTTY;
+  });
+
   it('should merge excludeTools from settings and extensions', async () => {
     const settings: Settings = { excludeTools: ['tool1', 'tool2'] };
     const extensions: Extension[] = [
@@ -655,7 +667,8 @@ describe('mergeExcludeTools', () => {
     expect(config.getExcludeTools()).toHaveLength(4);
   });
 
-  it('should return an empty array when no excludeTools are specified', async () => {
+  it('should return an empty array when no excludeTools are specified and it is interactive', async () => {
+    process.stdin.isTTY = true;
     const settings: Settings = {};
     const extensions: Extension[] = [];
     process.argv = ['node', 'script.js'];
@@ -669,6 +682,21 @@ describe('mergeExcludeTools', () => {
     expect(config.getExcludeTools()).toEqual([]);
   });
 
+  it('should return default excludes when no excludeTools are specified and it is not interactive', async () => {
+    process.stdin.isTTY = false;
+    const settings: Settings = {};
+    const extensions: Extension[] = [];
+    process.argv = ['node', 'script.js', '-p', 'test'];
+    const argv = await parseArguments();
+    const config = await loadCliConfig(
+      settings,
+      extensions,
+      'test-session',
+      argv,
+    );
+    expect(config.getExcludeTools()).toEqual(defaultExcludes);
+  });
+
   it('should handle settings with excludeTools but no extensions', async () => {
     process.argv = ['node', 'script.js'];
     const argv = await parseArguments();
@@ -1214,3 +1242,115 @@ describe('loadCliConfig chatCompression', () => {
     expect(config.getChatCompression()).toBeUndefined();
   });
 });
+
+describe('loadCliConfig tool exclusions', () => {
+  const originalArgv = process.argv;
+  const originalEnv = { ...process.env };
+  const originalIsTTY = process.stdin.isTTY;
+
+  beforeEach(() => {
+    vi.resetAllMocks();
+    vi.mocked(os.homedir).mockReturnValue('/mock/home/user');
+    process.env.GEMINI_API_KEY = 'test-api-key';
+    process.stdin.isTTY = true;
+  });
+
+  afterEach(() => {
+    process.argv = originalArgv;
+    process.env = originalEnv;
+    process.stdin.isTTY = originalIsTTY;
+    vi.restoreAllMocks();
+  });
+
+  it('should not exclude interactive tools in interactive mode without YOLO', async () => {
+    process.stdin.isTTY = true;
+    process.argv = ['node', 'script.js'];
+    const argv = await parseArguments();
+    const config = await loadCliConfig({}, [], 'test-session', argv);
+    expect(config.getExcludeTools()).not.toContain('run_shell_command');
+    expect(config.getExcludeTools()).not.toContain('replace');
+    expect(config.getExcludeTools()).not.toContain('write_file');
+  });
+
+  it('should not exclude interactive tools in interactive mode with YOLO', async () => {
+    process.stdin.isTTY = true;
+    process.argv = ['node', 'script.js', '--yolo'];
+    const argv = await parseArguments();
+    const config = await loadCliConfig({}, [], 'test-session', argv);
+    expect(config.getExcludeTools()).not.toContain('run_shell_command');
+    expect(config.getExcludeTools()).not.toContain('replace');
+    expect(config.getExcludeTools()).not.toContain('write_file');
+  });
+
+  it('should exclude interactive tools in non-interactive mode without YOLO', async () => {
+    process.stdin.isTTY = false;
+    process.argv = ['node', 'script.js', '-p', 'test'];
+    const argv = await parseArguments();
+    const config = await loadCliConfig({}, [], 'test-session', argv);
+    expect(config.getExcludeTools()).toContain('run_shell_command');
+    expect(config.getExcludeTools()).toContain('replace');
+    expect(config.getExcludeTools()).toContain('write_file');
+  });
+
+  it('should not exclude interactive tools in non-interactive mode with YOLO', async () => {
+    process.stdin.isTTY = false;
+    process.argv = ['node', 'script.js', '-p', 'test', '--yolo'];
+    const argv = await parseArguments();
+    const config = await loadCliConfig({}, [], 'test-session', argv);
+    expect(config.getExcludeTools()).not.toContain('run_shell_command');
+    expect(config.getExcludeTools()).not.toContain('replace');
+    expect(config.getExcludeTools()).not.toContain('write_file');
+  });
+});
+
+describe('loadCliConfig interactive', () => {
+  const originalArgv = process.argv;
+  const originalEnv = { ...process.env };
+  const originalIsTTY = process.stdin.isTTY;
+
+  beforeEach(() => {
+    vi.resetAllMocks();
+    vi.mocked(os.homedir).mockReturnValue('/mock/home/user');
+    process.env.GEMINI_API_KEY = 'test-api-key';
+    process.stdin.isTTY = true;
+  });
+
+  afterEach(() => {
+    process.argv = originalArgv;
+    process.env = originalEnv;
+    process.stdin.isTTY = originalIsTTY;
+    vi.restoreAllMocks();
+  });
+
+  it('should be interactive if isTTY and no prompt', async () => {
+    process.stdin.isTTY = true;
+    process.argv = ['node', 'script.js'];
+    const argv = await parseArguments();
+    const config = await loadCliConfig({}, [], 'test-session', argv);
+    expect(config.isInteractive()).toBe(true);
+  });
+
+  it('should be interactive if prompt-interactive is set', async () => {
+    process.stdin.isTTY = false;
+    process.argv = ['node', 'script.js', '--prompt-interactive', 'test'];
+    const argv = await parseArguments();
+    const config = await loadCliConfig({}, [], 'test-session', argv);
+    expect(config.isInteractive()).toBe(true);
+  });
+
+  it('should not be interactive if not isTTY and no prompt', async () => {
+    process.stdin.isTTY = false;
+    process.argv = ['node', 'script.js'];
+    const argv = await parseArguments();
+    const config = await loadCliConfig({}, [], 'test-session', argv);
+    expect(config.isInteractive()).toBe(false);
+  });
+
+  it('should not be interactive if prompt is set', async () => {
+    process.stdin.isTTY = true;
+    process.argv = ['node', 'script.js', '--prompt', 'test'];
+    const argv = await parseArguments();
+    const config = await loadCliConfig({}, [], 'test-session', argv);
+    expect(config.isInteractive()).toBe(false);
+  });
+});
diff --git a/packages/cli/src/config/config.ts b/packages/cli/src/config/config.ts
index 3104e4c1..d142bd12 100644
--- a/packages/cli/src/config/config.ts
+++ b/packages/cli/src/config/config.ts
@@ -23,6 +23,9 @@ import {
   FileDiscoveryService,
   TelemetryTarget,
   FileFilteringOptions,
+  ShellTool,
+  EditTool,
+  WriteFileTool,
 } from '@google/gemini-cli-core';
 import { Settings } from './settings.js';
 
@@ -365,7 +368,22 @@ export async function loadCliConfig(
   );
 
   let mcpServers = mergeMcpServers(settings, activeExtensions);
-  const excludeTools = mergeExcludeTools(settings, activeExtensions);
+  const question = argv.promptInteractive || argv.prompt || '';
+  const approvalMode =
+    argv.yolo || false ? ApprovalMode.YOLO : ApprovalMode.DEFAULT;
+  const interactive =
+    !!argv.promptInteractive || (process.stdin.isTTY && question.length === 0);
+  // In non-interactive and non-yolo mode, exclude interactive built in tools.
+  const extraExcludes =
+    !interactive && approvalMode !== ApprovalMode.YOLO
+      ? [ShellTool.Name, EditTool.Name, WriteFileTool.Name]
+      : undefined;
+
+  const excludeTools = mergeExcludeTools(
+    settings,
+    activeExtensions,
+    extraExcludes,
+  );
   const blockedMcpServers: Array<{ name: string; extensionName: string }> = [];
 
   if (!argv.allowedMcpServerNames) {
@@ -427,7 +445,7 @@ export async function loadCliConfig(
       settings.loadMemoryFromIncludeDirectories ||
       false,
     debugMode,
-    question: argv.promptInteractive || argv.prompt || '',
+    question,
     fullContext: argv.allFiles || argv.all_files || false,
     coreTools: settings.coreTools || undefined,
     excludeTools,
@@ -437,7 +455,7 @@ export async function loadCliConfig(
     mcpServers,
     userMemory: memoryContent,
     geminiMdFileCount: fileCount,
-    approvalMode: argv.yolo || false ? ApprovalMode.YOLO : ApprovalMode.DEFAULT,
+    approvalMode,
     showMemoryUsage:
       argv.showMemoryUsage ||
       argv.show_memory_usage ||
@@ -486,6 +504,7 @@ export async function loadCliConfig(
     ideModeFeature,
     chatCompression: settings.chatCompression,
     folderTrustFeature,
+    interactive,
     folderTrust,
   });
 }
@@ -514,8 +533,12 @@ function mergeMcpServers(settings: Settings, extensions: Extension[]) {
 function mergeExcludeTools(
   settings: Settings,
   extensions: Extension[],
+  extraExcludes?: string[] | undefined,
 ): string[] {
-  const allExcludeTools = new Set(settings.excludeTools || []);
+  const allExcludeTools = new Set([
+    ...(settings.excludeTools || []),
+    ...(extraExcludes || []),
+  ]);
   for (const extension of extensions) {
     for (const tool of extension.config.excludeTools || []) {
       allExcludeTools.add(tool);
diff --git a/packages/cli/src/gemini.tsx b/packages/cli/src/gemini.tsx
index 48dbd271..771fcacb 100644
--- a/packages/cli/src/gemini.tsx
+++ b/packages/cli/src/gemini.tsx
@@ -7,7 +7,7 @@
 import React from 'react';
 import { render } from 'ink';
 import { AppWrapper } from './ui/App.js';
-import { loadCliConfig, parseArguments, CliArgs } from './config/config.js';
+import { loadCliConfig, parseArguments } from './config/config.js';
 import { readStdin } from './utils/readStdin.js';
 import { basename } from 'node:path';
 import v8 from 'node:v8';
@@ -25,15 +25,11 @@ import { themeManager } from './ui/themes/theme-manager.js';
 import { getStartupWarnings } from './utils/startupWarnings.js';
 import { getUserStartupWarnings } from './utils/userStartupWarnings.js';
 import { runNonInteractive } from './nonInteractiveCli.js';
-import { loadExtensions, Extension } from './config/extension.js';
+import { loadExtensions } from './config/extension.js';
 import { cleanupCheckpoints, registerCleanup } from './utils/cleanup.js';
 import { getCliVersion } from './utils/version.js';
 import {
-  ApprovalMode,
   Config,
-  EditTool,
-  ShellTool,
-  WriteFileTool,
   sessionId,
   logUserPrompt,
   AuthType,
@@ -255,11 +251,8 @@ export async function main() {
     ...(await getUserStartupWarnings(workspaceRoot)),
   ];
 
-  const shouldBeInteractive =
-    !!argv.promptInteractive || (process.stdin.isTTY && input?.length === 0);
-
   // Render UI, passing necessary config values. Check that there is no command line question.
-  if (shouldBeInteractive) {
+  if (config.isInteractive()) {
     const version = await getCliVersion();
     setWindowTitle(basename(workspaceRoot), settings);
     const instance = render(
@@ -308,12 +301,10 @@ export async function main() {
     prompt_length: input.length,
   });
 
-  // Non-interactive mode handled by runNonInteractive
-  const nonInteractiveConfig = await loadNonInteractiveConfig(
+  const nonInteractiveConfig = await validateNonInteractiveAuth(
+    settings.merged.selectedAuthType,
+    settings.merged.useExternalAuth,
     config,
-    extensions,
-    settings,
-    argv,
   );
 
   await runNonInteractive(nonInteractiveConfig, input, prompt_id);
@@ -334,43 +325,3 @@ function setWindowTitle(title: string, settings: LoadedSettings) {
     });
   }
 }
-
-async function loadNonInteractiveConfig(
-  config: Config,
-  extensions: Extension[],
-  settings: LoadedSettings,
-  argv: CliArgs,
-) {
-  let finalConfig = config;
-  if (config.getApprovalMode() !== ApprovalMode.YOLO) {
-    // Everything is not allowed, ensure that only read-only tools are configured.
-    const existingExcludeTools = settings.merged.excludeTools || [];
-    const interactiveTools = [
-      ShellTool.Name,
-      EditTool.Name,
-      WriteFileTool.Name,
-    ];
-
-    const newExcludeTools = [
-      ...new Set([...existingExcludeTools, ...interactiveTools]),
-    ];
-
-    const nonInteractiveSettings = {
-      ...settings.merged,
-      excludeTools: newExcludeTools,
-    };
-    finalConfig = await loadCliConfig(
-      nonInteractiveSettings,
-      extensions,
-      config.getSessionId(),
-      argv,
-    );
-    await finalConfig.initialize();
-  }
-
-  return await validateNonInteractiveAuth(
-    settings.merged.selectedAuthType,
-    settings.merged.useExternalAuth,
-    finalConfig,
-  );
-}
diff --git a/packages/cli/src/nonInteractiveCli.ts b/packages/cli/src/nonInteractiveCli.ts
index 8b056a28..95ed70cf 100644
--- a/packages/cli/src/nonInteractiveCli.ts
+++ b/packages/cli/src/nonInteractiveCli.ts
@@ -30,7 +30,6 @@ export async function runNonInteractive(
   });
 
   try {
-    await config.initialize();
     consolePatcher.patch();
     // Handle EPIPE errors when the output is piped to a command that closes early.
     process.stdout.on('error', (err: NodeJS.ErrnoException) => {
diff --git a/packages/core/src/config/config.test.ts b/packages/core/src/config/config.test.ts
index 64692139..8e6ca38f 100644
--- a/packages/core/src/config/config.test.ts
+++ b/packages/core/src/config/config.test.ts
@@ -150,6 +150,18 @@ describe('Server Config (config.ts)', () => {
 
       await expect(config.initialize()).resolves.toBeUndefined();
     });
+
+    it('should throw an error if initialized more than once', async () => {
+      const config = new Config({
+        ...baseParams,
+        checkpointing: false,
+      });
+
+      await expect(config.initialize()).resolves.toBeUndefined();
+      await expect(config.initialize()).rejects.toThrow(
+        'Config was already initialized',
+      );
+    });
   });
 
   describe('refreshAuth', () => {
diff --git a/packages/core/src/config/config.ts b/packages/core/src/config/config.ts
index db226c76..473ab5a6 100644
--- a/packages/core/src/config/config.ts
+++ b/packages/core/src/config/config.ts
@@ -197,6 +197,7 @@ export interface ConfigParameters {
   ideMode?: boolean;
   loadMemoryFromIncludeDirectories?: boolean;
   chatCompression?: ChatCompressionSettings;
+  interactive?: boolean;
 }
 
 export class Config {
@@ -260,6 +261,8 @@ export class Config {
   private readonly experimentalAcp: boolean = false;
   private readonly loadMemoryFromIncludeDirectories: boolean = false;
   private readonly chatCompression: ChatCompressionSettings | undefined;
+  private readonly interactive: boolean;
+  private initialized: boolean = false;
 
   constructor(params: ConfigParameters) {
     this.sessionId = params.sessionId;
@@ -326,6 +329,7 @@ export class Config {
     this.loadMemoryFromIncludeDirectories =
       params.loadMemoryFromIncludeDirectories ?? false;
     this.chatCompression = params.chatCompression;
+    this.interactive = params.interactive ?? false;
 
     if (params.contextFileName) {
       setGeminiMdFilename(params.contextFileName);
@@ -344,7 +348,14 @@ export class Config {
     }
   }
 
+  /**
+   * Must only be called once, throws if called again.
+   */
   async initialize(): Promise<void> {
+    if (this.initialized) {
+      throw Error('Config was already initialized');
+    }
+    this.initialized = true;
     // Initialize centralized FileDiscoveryService
     this.getFileService();
     if (this.getCheckpointingEnabled()) {
@@ -685,6 +696,10 @@ export class Config {
     return this.chatCompression;
   }
 
+  isInteractive(): boolean {
+    return this.interactive;
+  }
+
   async getGitService(): Promise<GitService> {
     if (!this.gitService) {
       this.gitService = new GitService(this.targetDir);

From 4d4eacfc40f87ecc991aaecc12c046d49654425c Mon Sep 17 00:00:00 2001
From: Shreya Keshive <skeshive@gmail.com>
Date: Thu, 7 Aug 2025 17:19:31 -0400
Subject: [PATCH 043/107] Few IDE integration polishes (#5727)

---
 .../IDEContextDetailDisplay.test.tsx          | 66 +++++++++++++++++++
 .../ui/components/IDEContextDetailDisplay.tsx | 27 ++++++--
 .../IDEContextDetailDisplay.test.tsx.snap     | 24 +++++++
 packages/core/src/ide/ide-client.ts           | 43 ++++++++++--
 4 files changed, 150 insertions(+), 10 deletions(-)
 create mode 100644 packages/cli/src/ui/components/IDEContextDetailDisplay.test.tsx
 create mode 100644 packages/cli/src/ui/components/__snapshots__/IDEContextDetailDisplay.test.tsx.snap

diff --git a/packages/cli/src/ui/components/IDEContextDetailDisplay.test.tsx b/packages/cli/src/ui/components/IDEContextDetailDisplay.test.tsx
new file mode 100644
index 00000000..629d6c2e
--- /dev/null
+++ b/packages/cli/src/ui/components/IDEContextDetailDisplay.test.tsx
@@ -0,0 +1,66 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { render } from 'ink-testing-library';
+import { describe, it, expect } from 'vitest';
+import { IDEContextDetailDisplay } from './IDEContextDetailDisplay.js';
+import { type IdeContext } from '@google/gemini-cli-core';
+
+describe('IDEContextDetailDisplay', () => {
+  it('renders an empty string when there are no open files', () => {
+    const ideContext: IdeContext = {
+      workspaceState: {
+        openFiles: [],
+      },
+    };
+    const { lastFrame } = render(
+      <IDEContextDetailDisplay
+        ideContext={ideContext}
+        detectedIdeDisplay="VS Code"
+      />,
+    );
+    expect(lastFrame()).toBe('');
+  });
+
+  it('renders a list of open files with active status', () => {
+    const ideContext: IdeContext = {
+      workspaceState: {
+        openFiles: [
+          { path: '/foo/bar.txt', isActive: true },
+          { path: '/foo/baz.txt', isActive: false },
+        ],
+      },
+    };
+    const { lastFrame } = render(
+      <IDEContextDetailDisplay
+        ideContext={ideContext}
+        detectedIdeDisplay="VS Code"
+      />,
+    );
+    const output = lastFrame();
+    expect(output).toMatchSnapshot();
+  });
+
+  it('handles duplicate basenames by showing path hints', () => {
+    const ideContext: IdeContext = {
+      workspaceState: {
+        openFiles: [
+          { path: '/foo/bar.txt', isActive: true },
+          { path: '/qux/bar.txt', isActive: false },
+          { path: '/foo/unique.txt', isActive: false },
+        ],
+      },
+    };
+    const { lastFrame } = render(
+      <IDEContextDetailDisplay
+        ideContext={ideContext}
+        detectedIdeDisplay="VS Code"
+      />,
+    );
+    const output = lastFrame();
+    expect(output).toMatchSnapshot();
+  });
+});
diff --git a/packages/cli/src/ui/components/IDEContextDetailDisplay.tsx b/packages/cli/src/ui/components/IDEContextDetailDisplay.tsx
index a1739227..ec3c2dad 100644
--- a/packages/cli/src/ui/components/IDEContextDetailDisplay.tsx
+++ b/packages/cli/src/ui/components/IDEContextDetailDisplay.tsx
@@ -23,6 +23,12 @@ export function IDEContextDetailDisplay({
     return null;
   }
 
+  const basenameCounts = new Map<string, number>();
+  for (const file of openFiles) {
+    const basename = path.basename(file.path);
+    basenameCounts.set(basename, (basenameCounts.get(basename) || 0) + 1);
+  }
+
   return (
     <Box
       flexDirection="column"
@@ -38,12 +44,21 @@ export function IDEContextDetailDisplay({
       {openFiles.length > 0 && (
         <Box flexDirection="column" marginTop={1}>
           <Text bold>Open files:</Text>
-          {openFiles.map((file: File) => (
-            <Text key={file.path}>
-              - {path.basename(file.path)}
-              {file.isActive ? ' (active)' : ''}
-            </Text>
-          ))}
+          {openFiles.map((file: File) => {
+            const basename = path.basename(file.path);
+            const isDuplicate = (basenameCounts.get(basename) || 0) > 1;
+            const parentDir = path.basename(path.dirname(file.path));
+            const displayName = isDuplicate
+              ? `${basename} (/${parentDir})`
+              : basename;
+
+            return (
+              <Text key={file.path}>
+                - {displayName}
+                {file.isActive ? ' (active)' : ''}
+              </Text>
+            );
+          })}
         </Box>
       )}
     </Box>
diff --git a/packages/cli/src/ui/components/__snapshots__/IDEContextDetailDisplay.test.tsx.snap b/packages/cli/src/ui/components/__snapshots__/IDEContextDetailDisplay.test.tsx.snap
new file mode 100644
index 00000000..8b84e1f3
--- /dev/null
+++ b/packages/cli/src/ui/components/__snapshots__/IDEContextDetailDisplay.test.tsx.snap
@@ -0,0 +1,24 @@
+// Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
+
+exports[`IDEContextDetailDisplay > handles duplicate basenames by showing path hints 1`] = `
+"
+╭──────────────────────────────────────────────────────────────────────────────────────────────────╮
+│ VS Code Context (ctrl+e to toggle)                                                               │
+│                                                                                                  │
+│ Open files:                                                                                      │
+│ - bar.txt (/foo) (active)                                                                        │
+│ - bar.txt (/qux)                                                                                 │
+│ - unique.txt                                                                                     │
+╰──────────────────────────────────────────────────────────────────────────────────────────────────╯"
+`;
+
+exports[`IDEContextDetailDisplay > renders a list of open files with active status 1`] = `
+"
+╭──────────────────────────────────────────────────────────────────────────────────────────────────╮
+│ VS Code Context (ctrl+e to toggle)                                                               │
+│                                                                                                  │
+│ Open files:                                                                                      │
+│ - bar.txt (active)                                                                               │
+│ - baz.txt                                                                                        │
+╰──────────────────────────────────────────────────────────────────────────────────────────────────╯"
+`;
diff --git a/packages/core/src/ide/ide-client.ts b/packages/core/src/ide/ide-client.ts
index 42b79c44..508dfea1 100644
--- a/packages/core/src/ide/ide-client.ts
+++ b/packages/core/src/ide/ide-client.ts
@@ -4,6 +4,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
+import * as fs from 'node:fs';
 import {
   detectIde,
   DetectedIde,
@@ -23,6 +24,8 @@ import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/
 const logger = {
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   debug: (...args: any[]) => console.debug('[DEBUG] [IDEClient]', ...args),
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  error: (...args: any[]) => console.error('[ERROR] [IDEClient]', ...args),
 };
 
 export type IDEConnectionState = {
@@ -36,6 +39,16 @@ export enum IDEConnectionStatus {
   Connecting = 'connecting',
 }
 
+function getRealPath(path: string): string {
+  try {
+    return fs.realpathSync(path);
+  } catch (_e) {
+    // If realpathSync fails, it might be because the path doesn't exist.
+    // In that case, we can fall back to the original path.
+    return path;
+  }
+}
+
 /**
  * Manages the connection to and interaction with the IDE server.
  */
@@ -69,7 +82,15 @@ export class IdeClient {
     this.setState(IDEConnectionStatus.Connecting);
 
     if (!this.currentIde || !this.currentIdeDisplayName) {
-      this.setState(IDEConnectionStatus.Disconnected);
+      this.setState(
+        IDEConnectionStatus.Disconnected,
+        `IDE integration is not supported in your current environment. To use this feature, run Gemini CLI in one of these supported IDEs: ${Object.values(
+          DetectedIde,
+        )
+          .map((ide) => getIdeDisplayName(ide))
+          .join(', ')}`,
+        true,
+      );
       return;
     }
 
@@ -174,7 +195,11 @@ export class IdeClient {
     return this.currentIdeDisplayName;
   }
 
-  private setState(status: IDEConnectionStatus, details?: string) {
+  private setState(
+    status: IDEConnectionStatus,
+    details?: string,
+    logToConsole = false,
+  ) {
     const isAlreadyDisconnected =
       this.state.status === IDEConnectionStatus.Disconnected &&
       status === IDEConnectionStatus.Disconnected;
@@ -186,7 +211,10 @@ export class IdeClient {
     }
 
     if (status === IDEConnectionStatus.Disconnected) {
-      logger.debug('IDE integration disconnected:', details);
+      if (logToConsole) {
+        logger.error(details);
+      }
+      logger.debug(details);
       ideContext.clearIdeContext();
     }
   }
@@ -197,6 +225,7 @@ export class IdeClient {
       this.setState(
         IDEConnectionStatus.Disconnected,
         `Failed to connect to IDE companion extension for ${this.currentIdeDisplayName}. Please ensure the extension is running and try refreshing your terminal. To install the extension, run /ide install.`,
+        true,
       );
       return false;
     }
@@ -204,13 +233,15 @@ export class IdeClient {
       this.setState(
         IDEConnectionStatus.Disconnected,
         `To use this feature, please open a single workspace folder in ${this.currentIdeDisplayName} and try again.`,
+        true,
       );
       return false;
     }
-    if (ideWorkspacePath !== process.cwd()) {
+    if (getRealPath(ideWorkspacePath) !== getRealPath(process.cwd())) {
       this.setState(
         IDEConnectionStatus.Disconnected,
         `Directory mismatch. Gemini CLI is running in a different location than the open workspace in ${this.currentIdeDisplayName}. Please run the CLI from the same directory as your project's root folder.`,
+        true,
       );
       return false;
     }
@@ -223,6 +254,7 @@ export class IdeClient {
       this.setState(
         IDEConnectionStatus.Disconnected,
         `Failed to connect to IDE companion extension for ${this.currentIdeDisplayName}. Please ensure the extension is running and try refreshing your terminal. To install the extension, run /ide install.`,
+        true,
       );
       return undefined;
     }
@@ -244,12 +276,14 @@ export class IdeClient {
       this.setState(
         IDEConnectionStatus.Disconnected,
         `IDE connection error. The connection was lost unexpectedly. Please try reconnecting by running /ide enable`,
+        true,
       );
     };
     this.client.onclose = () => {
       this.setState(
         IDEConnectionStatus.Disconnected,
         `IDE connection error. The connection was lost unexpectedly. Please try reconnecting by running /ide enable`,
+        true,
       );
     };
     this.client.setNotificationHandler(
@@ -299,6 +333,7 @@ export class IdeClient {
       this.setState(
         IDEConnectionStatus.Disconnected,
         `Failed to connect to IDE companion extension for ${this.currentIdeDisplayName}. Please ensure the extension is running and try refreshing your terminal. To install the extension, run /ide install.`,
+        true,
       );
       if (transport) {
         try {

From f1663d9615edee825b4f3e077183aeb4c781361b Mon Sep 17 00:00:00 2001
From: Shreya Keshive <skeshive@gmail.com>
Date: Thu, 7 Aug 2025 17:25:06 -0400
Subject: [PATCH 044/107] README + reduce required VS Code version for
 companion extension (#5719)

---
 package-lock.json                              | 18 +++++++++---------
 packages/vscode-ide-companion/README.md        |  6 +++++-
 packages/vscode-ide-companion/package.json     |  4 ++--
 .../vscode-ide-companion/src/diff-manager.ts   | 10 +++-------
 packages/vscode-ide-companion/src/extension.ts |  2 +-
 5 files changed, 20 insertions(+), 20 deletions(-)

diff --git a/package-lock.json b/package-lock.json
index e254cab8..2efb7e40 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -2511,13 +2511,6 @@
         "boxen": "^7.1.1"
       }
     },
-    "node_modules/@types/vscode": {
-      "version": "1.102.0",
-      "resolved": "https://registry.npmjs.org/@types/vscode/-/vscode-1.102.0.tgz",
-      "integrity": "sha512-V9sFXmcXz03FtYTSUsYsu5K0Q9wH9w9V25slddcxrh5JgORD14LpnOA7ov0L9ALi+6HrTjskLJ/tY5zeRF3TFA==",
-      "dev": true,
-      "license": "MIT"
-    },
     "node_modules/@types/ws": {
       "version": "8.18.1",
       "resolved": "https://registry.npmjs.org/@types/ws/-/ws-8.18.1.tgz",
@@ -12029,7 +12022,7 @@
         "@types/cors": "^2.8.19",
         "@types/express": "^5.0.3",
         "@types/node": "20.x",
-        "@types/vscode": "^1.101.0",
+        "@types/vscode": "^1.99.0",
         "@typescript-eslint/eslint-plugin": "^8.31.1",
         "@typescript-eslint/parser": "^8.31.1",
         "esbuild": "^0.25.3",
@@ -12039,8 +12032,15 @@
         "vitest": "^3.2.4"
       },
       "engines": {
-        "vscode": "^1.101.0"
+        "vscode": "^1.99.0"
       }
+    },
+    "packages/vscode-ide-companion/node_modules/@types/vscode": {
+      "version": "1.99.0",
+      "resolved": "https://registry.npmjs.org/@types/vscode/-/vscode-1.99.0.tgz",
+      "integrity": "sha512-30sjmas1hQ0gVbX68LAWlm/YYlEqUErunPJJKLpEl+xhK0mKn+jyzlCOpsdTwfkZfPy4U6CDkmygBLC3AB8W9Q==",
+      "dev": true,
+      "license": "MIT"
     }
   }
 }
diff --git a/packages/vscode-ide-companion/README.md b/packages/vscode-ide-companion/README.md
index 1b96d7f3..49de94a1 100644
--- a/packages/vscode-ide-companion/README.md
+++ b/packages/vscode-ide-companion/README.md
@@ -8,11 +8,15 @@ The Gemini CLI Companion extension seamlessly integrates [Gemini CLI](https://gi
 
 - Selection Context: Gemini CLI can easily access your cursor's position and selected text within the editor, giving it valuable context directly from your current work.
 
+- Native Diffing: Seamlessly view, modify, and accept code changes suggested by Gemini CLI directly within the editor.
+
+- Launch Gemini CLI: Quickly start a new Gemini CLI session from the Command Palette (Cmd+Shift+P or Ctrl+Shift+P) by running the "Gemini CLI: Run" command.
+
 # Requirements
 
 To use this extension, you'll need:
 
-- VS Code version 1.101.0 or newer
+- VS Code version 1.99.0 or newer
 - Gemini CLI (installed separately) running within the VS Code integrated terminal
 
 # Terms of Service and Privacy Notice
diff --git a/packages/vscode-ide-companion/package.json b/packages/vscode-ide-companion/package.json
index aee14e32..2ed5cd21 100644
--- a/packages/vscode-ide-companion/package.json
+++ b/packages/vscode-ide-companion/package.json
@@ -11,7 +11,7 @@
     "directory": "packages/vscode-ide-companion"
   },
   "engines": {
-    "vscode": "^1.101.0"
+    "vscode": "^1.99.0"
   },
   "license": "LICENSE",
   "preview": true,
@@ -113,7 +113,7 @@
     "@types/cors": "^2.8.19",
     "@types/express": "^5.0.3",
     "@types/node": "20.x",
-    "@types/vscode": "^1.101.0",
+    "@types/vscode": "^1.99.0",
     "@typescript-eslint/eslint-plugin": "^8.31.1",
     "@typescript-eslint/parser": "^8.31.1",
     "esbuild": "^0.25.3",
diff --git a/packages/vscode-ide-companion/src/diff-manager.ts b/packages/vscode-ide-companion/src/diff-manager.ts
index 0dad03a6..d2a53b54 100644
--- a/packages/vscode-ide-companion/src/diff-manager.ts
+++ b/packages/vscode-ide-companion/src/diff-manager.ts
@@ -56,7 +56,7 @@ export class DiffManager {
   private diffDocuments = new Map<string, DiffInfo>();
 
   constructor(
-    private readonly logger: vscode.OutputChannel,
+    private readonly log: (message: string) => void,
     private readonly diffContentProvider: DiffContentProvider,
   ) {}
 
@@ -151,9 +151,7 @@ export class DiffManager {
   async acceptDiff(rightDocUri: vscode.Uri) {
     const diffInfo = this.diffDocuments.get(rightDocUri.toString());
     if (!diffInfo) {
-      this.logger.appendLine(
-        `No diff info found for ${rightDocUri.toString()}`,
-      );
+      this.log(`No diff info found for ${rightDocUri.toString()}`);
       return;
     }
 
@@ -179,9 +177,7 @@ export class DiffManager {
   async cancelDiff(rightDocUri: vscode.Uri) {
     const diffInfo = this.diffDocuments.get(rightDocUri.toString());
     if (!diffInfo) {
-      this.logger.appendLine(
-        `No diff info found for ${rightDocUri.toString()}`,
-      );
+      this.log(`No diff info found for ${rightDocUri.toString()}`);
       // Even if we don't have diff info, we should still close the editor.
       await this.closeDiffEditor(rightDocUri);
       return;
diff --git a/packages/vscode-ide-companion/src/extension.ts b/packages/vscode-ide-companion/src/extension.ts
index 08389731..18217140 100644
--- a/packages/vscode-ide-companion/src/extension.ts
+++ b/packages/vscode-ide-companion/src/extension.ts
@@ -42,7 +42,7 @@ export async function activate(context: vscode.ExtensionContext) {
   updateWorkspacePath(context);
 
   const diffContentProvider = new DiffContentProvider();
-  const diffManager = new DiffManager(logger, diffContentProvider);
+  const diffManager = new DiffManager(log, diffContentProvider);
 
   context.subscriptions.push(
     vscode.workspace.onDidCloseTextDocument((doc) => {

From 908ce2be337087de03df4986d12dd36cedd40f1e Mon Sep 17 00:00:00 2001
From: Gaurav <39389231+gsquared94@users.noreply.github.com>
Date: Thu, 7 Aug 2025 14:57:54 -0700
Subject: [PATCH 045/107] update: `google-github-actions/run-gemini-cli`
 version in workflows (#5802)

---
 .../gemini-automated-issue-triage.yml         | 19 ++++++++++---------
 .../gemini-scheduled-issue-triage.yml         |  2 +-
 2 files changed, 11 insertions(+), 10 deletions(-)

diff --git a/.github/workflows/gemini-automated-issue-triage.yml b/.github/workflows/gemini-automated-issue-triage.yml
index d29484f7..c9381833 100644
--- a/.github/workflows/gemini-automated-issue-triage.yml
+++ b/.github/workflows/gemini-automated-issue-triage.yml
@@ -55,7 +55,7 @@ jobs:
           private-key: '${{ secrets.PRIVATE_KEY }}'
 
       - name: 'Run Gemini Issue Triage'
-        uses: 'google-github-actions/run-gemini-cli@68d5a6d2e31ff01029205c58c6bf81cb3d72910b'
+        uses: 'google-github-actions/run-gemini-cli@20351b5ea2b4179431f1ae8918a246a0808f8747'
         id: 'gemini_issue_triage'
         env:
           GITHUB_TOKEN: '${{ steps.generate_token.outputs.token }}'
@@ -87,26 +87,27 @@ jobs:
           prompt: |-
             ## Role
 
-            You are an issue triage assistant. Analyze the current GitHub issues apply the most appropriate existing labels. Do not remove labels titled help wanted or good first issue.
+            You are an issue triage assistant. Analyze the current GitHub issue and apply the most appropriate existing labels. Use the available
+            tools to gather information; do not ask for information to be provided. Do not remove labels titled help wanted or good first issue.
 
             ## Steps
 
             1. Run: `gh label list --repo ${{ github.repository }} --limit 100` to get all available labels.
-            2. Review the issue title, body and any comments provided in the environment variables.
+            2. Review the issue title and body provided in the environment variables: "${ISSUE_TITLE}" and "${ISSUE_BODY}".
             3. Ignore any existing priorities or tags on the issue. Just report your findings.
             4. Select the most relevant labels from the existing labels, focusing on kind/*, area/*, sub-area/* and priority/*. For area/* and kind/* limit yourself to only the single most applicable label in each case. 
-            6. Apply the selected labels to this issue using: `gh issue edit ${{ github.event.issue.number }} --repo ${{ github.repository }} --add-label "label1,label2"`
-            7. For each issue please check if CLI version is present, this is usually in the output of the /about command  and will look like 0.1.5 for anything more than 6 versions older than the most recent should add the status/need-retesting label
-            8. If you see that the issue doesn’t look like it has sufficient information recommend the status/need-information label
-            9. Use Area definitions mentioned below to help you narrow down issues
+            6. Apply the selected labels to this issue using: `gh issue edit ${{ github.event.issue.number }} --repo ${{ github.repository }} --add-label "label1,label2"`.
+            7. For each issue please check if CLI version is present, this is usually in the output of the /about command  and will look like 0.1.5 for anything more than 6 versions older than the most recent should add the status/need-retesting label.
+            8. If you see that the issue doesn’t look like it has sufficient information recommend the status/need-information label.
+            9. Use Area definitions mentioned below to help you narrow down issues.
 
             ## Guidelines
 
             - Only use labels that already exist in the repository.
             - Do not add comments or modify the issue content.
             - Triage only the current issue.
-            - Apply only one area/ label
-            - Apply only one kind/ label
+            - Apply only one area/ label.
+            - Apply only one kind/ label.
             - Apply all applicable sub-area/* and priority/* labels based on the issue content. It's ok to have multiple of these.
             - Once you categorize the issue if it needs information bump down the priority by 1 eg.. a p0 would become a p1 a p1 would become a p2. P2 and P3 can stay as is in this scenario.
             Categorization Guidelines: 
diff --git a/.github/workflows/gemini-scheduled-issue-triage.yml b/.github/workflows/gemini-scheduled-issue-triage.yml
index 4e6f8a00..97a81332 100644
--- a/.github/workflows/gemini-scheduled-issue-triage.yml
+++ b/.github/workflows/gemini-scheduled-issue-triage.yml
@@ -65,7 +65,7 @@ jobs:
       - name: 'Run Gemini Issue Triage'
         if: |-
           ${{ steps.find_issues.outputs.issues_to_triage != '[]' }}
-        uses: 'google-github-actions/run-gemini-cli@68d5a6d2e31ff01029205c58c6bf81cb3d72910b'
+        uses: 'google-github-actions/run-gemini-cli@20351b5ea2b4179431f1ae8918a246a0808f8747'
         id: 'gemini_issue_triage'
         env:
           GITHUB_TOKEN: '${{ steps.generate_token.outputs.token }}'

From c38147a3a61779ee9b82f656f03b51fc0e68e799 Mon Sep 17 00:00:00 2001
From: Richie Foreman <richie.foreman@gmail.com>
Date: Thu, 7 Aug 2025 18:16:57 -0400
Subject: [PATCH 046/107] chore(vscode settings): Update VsCode settings for
 quality-of-life (#5806)

Co-authored-by: Jacob Richman <jacob314@gmail.com>
---
 .vscode/settings.json | 15 ++++++++++++++-
 1 file changed, 14 insertions(+), 1 deletion(-)

diff --git a/.vscode/settings.json b/.vscode/settings.json
index 1e9031c3..25fad7e1 100644
--- a/.vscode/settings.json
+++ b/.vscode/settings.json
@@ -1,3 +1,16 @@
 {
-  "typescript.tsserver.experimental.enableProjectDiagnostics": true
+  "typescript.tsserver.experimental.enableProjectDiagnostics": true,
+  "editor.tabSize": 2,
+  "editor.rulers": [80],
+  "editor.detectIndentation": false,
+  "editor.insertSpaces": true,
+  "[typescript]": {
+    "editor.defaultFormatter": "esbenp.prettier-vscode"
+  },
+  "[json]": {
+    "editor.defaultFormatter": "esbenp.prettier-vscode"
+  },
+  "[javascript]": {
+    "editor.defaultFormatter": "esbenp.prettier-vscode"
+  }
 }

From 9fc7115b8654fc193f948570293485f16d89f60a Mon Sep 17 00:00:00 2001
From: Bryant Chandler <brychanrobot@gmail.com>
Date: Thu, 7 Aug 2025 15:24:55 -0700
Subject: [PATCH 047/107] perf(filesearch): Use async fzf for non-blocking file
 search (#5771)

Co-authored-by: Jacob Richman <jacob314@gmail.com>
---
 .../cli/src/ui/hooks/useAtCompletion.test.ts  |  6 +--
 packages/cli/src/ui/hooks/useAtCompletion.ts  |  2 +-
 .../core/src/utils/filesearch/fileSearch.ts   | 49 +++++++++++--------
 3 files changed, 33 insertions(+), 24 deletions(-)

diff --git a/packages/cli/src/ui/hooks/useAtCompletion.test.ts b/packages/cli/src/ui/hooks/useAtCompletion.test.ts
index aa198fc1..599f8fdf 100644
--- a/packages/cli/src/ui/hooks/useAtCompletion.test.ts
+++ b/packages/cli/src/ui/hooks/useAtCompletion.test.ts
@@ -157,7 +157,7 @@ describe('useAtCompletion', () => {
       });
     });
 
-    it('should NOT show a loading indicator for subsequent searches that complete under 100ms', async () => {
+    it('should NOT show a loading indicator for subsequent searches that complete under 200ms', async () => {
       const structure: FileSystemStructure = { 'a.txt': '', 'b.txt': '' };
       testRootDir = await createTmpDir(structure);
 
@@ -186,7 +186,7 @@ describe('useAtCompletion', () => {
       expect(result.current.isLoadingSuggestions).toBe(false);
     });
 
-    it('should show a loading indicator and clear old suggestions for subsequent searches that take longer than 100ms', async () => {
+    it('should show a loading indicator and clear old suggestions for subsequent searches that take longer than 200ms', async () => {
       const structure: FileSystemStructure = { 'a.txt': '', 'b.txt': '' };
       testRootDir = await createTmpDir(structure);
 
@@ -194,7 +194,7 @@ describe('useAtCompletion', () => {
       const originalSearch = FileSearch.prototype.search;
       vi.spyOn(FileSearch.prototype, 'search').mockImplementation(
         async function (...args) {
-          await new Promise((resolve) => setTimeout(resolve, 200));
+          await new Promise((resolve) => setTimeout(resolve, 300));
           return originalSearch.apply(this, args);
         },
       );
diff --git a/packages/cli/src/ui/hooks/useAtCompletion.ts b/packages/cli/src/ui/hooks/useAtCompletion.ts
index 82439c14..f6835dc8 100644
--- a/packages/cli/src/ui/hooks/useAtCompletion.ts
+++ b/packages/cli/src/ui/hooks/useAtCompletion.ts
@@ -194,7 +194,7 @@ export function useAtCompletion(props: UseAtCompletionProps): void {
 
       slowSearchTimer.current = setTimeout(() => {
         dispatch({ type: 'SET_LOADING', payload: true });
-      }, 100);
+      }, 200);
 
       try {
         const results = await fileSearch.current.search(state.pattern, {
diff --git a/packages/core/src/utils/filesearch/fileSearch.ts b/packages/core/src/utils/filesearch/fileSearch.ts
index 76a099f7..480d5815 100644
--- a/packages/core/src/utils/filesearch/fileSearch.ts
+++ b/packages/core/src/utils/filesearch/fileSearch.ts
@@ -11,7 +11,7 @@ import picomatch from 'picomatch';
 import { Ignore } from './ignore.js';
 import { ResultCache } from './result-cache.js';
 import * as cache from './crawlCache.js';
-import { Fzf, FzfResultItem } from 'fzf';
+import { AsyncFzf, FzfResultItem } from 'fzf';
 
 export type FileSearchOptions = {
   projectRoot: string;
@@ -78,18 +78,6 @@ export async function filter(
   return results;
 }
 
-/**
- * Filters a list of paths based on a given pattern using fzf.
- * @param allPaths The list of all paths to filter.
- * @param pattern The fzf pattern to filter by.
- * @returns The filtered and sorted list of paths.
- */
-function filterByFzf(allPaths: string[], pattern: string) {
-  return new Fzf(allPaths)
-    .find(pattern)
-    .map((entry: FzfResultItem) => entry.item);
-}
-
 export type SearchOptions = {
   signal?: AbortSignal;
   maxResults?: number;
@@ -105,6 +93,7 @@ export class FileSearch {
   private readonly ignore: Ignore = new Ignore();
   private resultCache: ResultCache | undefined;
   private allFiles: string[] = [];
+  private fzf: AsyncFzf<string[]> | undefined;
 
   /**
    * Constructs a new `FileSearch` instance.
@@ -136,24 +125,38 @@ export class FileSearch {
     pattern: string,
     options: SearchOptions = {},
   ): Promise<string[]> {
-    if (!this.resultCache) {
+    if (!this.resultCache || !this.fzf) {
       throw new Error('Engine not initialized. Call initialize() first.');
     }
 
     pattern = pattern || '*';
 
+    let filteredCandidates;
     const { files: candidates, isExactMatch } =
       await this.resultCache!.get(pattern);
 
-    let filteredCandidates;
     if (isExactMatch) {
+      // Use the cached result.
       filteredCandidates = candidates;
     } else {
-      // Apply the user's picomatch pattern filter
-      filteredCandidates = pattern.includes('*')
-        ? await filter(candidates, pattern, options.signal)
-        : filterByFzf(this.allFiles, pattern);
-      this.resultCache!.set(pattern, filteredCandidates);
+      let shouldCache = true;
+      if (pattern.includes('*')) {
+        filteredCandidates = await filter(candidates, pattern, options.signal);
+      } else {
+        filteredCandidates = await this.fzf
+          .find(pattern)
+          .then((results: Array<FzfResultItem<string>>) =>
+            results.map((entry: FzfResultItem<string>) => entry.item),
+          )
+          .catch(() => {
+            shouldCache = false;
+            return [];
+          });
+      }
+
+      if (shouldCache) {
+        this.resultCache!.set(pattern, filteredCandidates);
+      }
     }
 
     // Trade-off: We apply a two-stage filtering process.
@@ -287,5 +290,11 @@ export class FileSearch {
    */
   private buildResultCache(): void {
     this.resultCache = new ResultCache(this.allFiles, this.absoluteDir);
+    // The v1 algorithm is much faster since it only looks at the first
+    // occurence of the pattern. We use it for search spaces that have >20k
+    // files, because the v2 algorithm is just too slow in those cases.
+    this.fzf = new AsyncFzf(this.allFiles, {
+      fuzzy: this.allFiles.length > 20000 ? 'v1' : 'v2',
+    });
   }
 }

From 0c32a4061dc008f6483918a9e53cba8914e88bef Mon Sep 17 00:00:00 2001
From: Allen Hutchison <adh@google.com>
Date: Thu, 7 Aug 2025 15:38:21 -0700
Subject: [PATCH 048/107] fix(core): Replace flaky performance tests with
 robust correctness tests (#5795)

Co-authored-by: Jacob Richman <jacob314@gmail.com>
---
 .../core/src/tools/read-many-files.test.ts    |  22 ++--
 packages/core/src/utils/bfsFileSearch.test.ts | 101 ++++++------------
 2 files changed, 38 insertions(+), 85 deletions(-)

diff --git a/packages/core/src/tools/read-many-files.test.ts b/packages/core/src/tools/read-many-files.test.ts
index 4035a6b7..c6b34665 100644
--- a/packages/core/src/tools/read-many-files.test.ts
+++ b/packages/core/src/tools/read-many-files.test.ts
@@ -523,7 +523,7 @@ describe('ReadManyFilesTool', () => {
       fs.writeFileSync(fullPath, content);
     };
 
-    it('should process files in parallel for performance', async () => {
+    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'),
@@ -534,31 +534,21 @@ describe('ReadManyFilesTool', () => {
       const fileCount = 4;
       const files = createMultipleFiles(fileCount, 'Batch test');
 
-      // Mock with 100ms delay per file to simulate I/O operations
+      // Mock with 10ms delay per file to simulate I/O operations
       detectFileTypeSpy.mockImplementation(async (_filePath: string) => {
-        await new Promise((resolve) => setTimeout(resolve, 100));
+        await new Promise((resolve) => setTimeout(resolve, 10));
         return 'text';
       });
 
-      const startTime = Date.now();
       const params = { paths: files };
       const result = await tool.execute(params, new AbortController().signal);
-      const endTime = Date.now();
-
-      const processingTime = endTime - startTime;
-
-      console.log(
-        `Processing time: ${processingTime}ms for ${fileCount} files`,
-      );
-
-      // Verify parallel processing performance improvement
-      // Parallel processing should complete in ~100ms (single file time)
-      // Sequential would take ~400ms (4 files × 100ms each)
-      expect(processingTime).toBeLessThan(200); // Should PASS with parallel implementation
 
       // 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();
diff --git a/packages/core/src/utils/bfsFileSearch.test.ts b/packages/core/src/utils/bfsFileSearch.test.ts
index ce19f80e..f9d76e38 100644
--- a/packages/core/src/utils/bfsFileSearch.test.ts
+++ b/packages/core/src/utils/bfsFileSearch.test.ts
@@ -190,80 +190,43 @@ describe('bfsFileSearch', () => {
     });
   });
 
-  it('should perform parallel directory scanning efficiently (performance test)', async () => {
-    // Create a more complex directory structure for performance testing
-    console.log('\n🚀 Testing Parallel BFS Performance...');
+  it('should find all files in a complex directory structure', async () => {
+    // Create a complex directory structure to test correctness at scale
+    // without flaky performance checks.
+    const numDirs = 50;
+    const numFilesPerDir = 2;
+    const numTargetDirs = 10;
 
-    // Create 50 directories with multiple levels for faster test execution
-    for (let i = 0; i < 50; i++) {
-      await createEmptyDir(`dir${i}`);
-      await createEmptyDir(`dir${i}`, 'subdir1');
-      await createEmptyDir(`dir${i}`, 'subdir2');
-      await createEmptyDir(`dir${i}`, 'subdir1', 'deep');
-      if (i < 10) {
-        // Add target files in some directories
-        await createTestFile('content', `dir${i}`, 'GEMINI.md');
-        await createTestFile('content', `dir${i}`, 'subdir1', 'GEMINI.md');
-      }
+    const dirCreationPromises: Array<Promise<unknown>> = [];
+    for (let i = 0; i < numDirs; i++) {
+      dirCreationPromises.push(createEmptyDir(`dir${i}`));
+      dirCreationPromises.push(createEmptyDir(`dir${i}`, 'subdir1'));
+      dirCreationPromises.push(createEmptyDir(`dir${i}`, 'subdir2'));
+      dirCreationPromises.push(createEmptyDir(`dir${i}`, 'subdir1', 'deep'));
     }
+    await Promise.all(dirCreationPromises);
 
-    // Run multiple iterations to ensure consistency
-    const iterations = 3;
-    const durations: number[] = [];
-    let foundFiles = 0;
-    let firstResultSorted: string[] | undefined;
-
-    for (let i = 0; i < iterations; i++) {
-      const searchStartTime = performance.now();
-      const result = await bfsFileSearch(testRootDir, {
-        fileName: 'GEMINI.md',
-        maxDirs: 200,
-        debug: false,
-      });
-      const duration = performance.now() - searchStartTime;
-      durations.push(duration);
-
-      // Verify consistency: all iterations should find the exact same files
-      if (firstResultSorted === undefined) {
-        foundFiles = result.length;
-        firstResultSorted = result.sort();
-      } else {
-        expect(result.sort()).toEqual(firstResultSorted);
-      }
-
-      console.log(`📊 Iteration ${i + 1}: ${duration.toFixed(2)}ms`);
+    const fileCreationPromises: Array<Promise<string>> = [];
+    for (let i = 0; i < numTargetDirs; i++) {
+      // Add target files in some directories
+      fileCreationPromises.push(
+        createTestFile('content', `dir${i}`, 'GEMINI.md'),
+      );
+      fileCreationPromises.push(
+        createTestFile('content', `dir${i}`, 'subdir1', 'GEMINI.md'),
+      );
     }
+    const expectedFiles = await Promise.all(fileCreationPromises);
 
-    const avgDuration = durations.reduce((a, b) => a + b, 0) / durations.length;
-    const maxDuration = Math.max(...durations);
-    const minDuration = Math.min(...durations);
+    const result = await bfsFileSearch(testRootDir, {
+      fileName: 'GEMINI.md',
+      // Provide a generous maxDirs limit to ensure it doesn't prematurely stop
+      // in this large test case. Total dirs created is 200.
+      maxDirs: 250,
+    });
 
-    console.log(`📊 Average Duration: ${avgDuration.toFixed(2)}ms`);
-    console.log(
-      `📊 Min/Max Duration: ${minDuration.toFixed(2)}ms / ${maxDuration.toFixed(2)}ms`,
-    );
-    console.log(`📁 Found ${foundFiles} GEMINI.md files`);
-    console.log(
-      `🏎️  Processing ~${Math.round(200 / (avgDuration / 1000))} dirs/second`,
-    );
-
-    // Verify we found the expected files
-    expect(foundFiles).toBe(20); // 10 dirs * 2 files each
-
-    // Performance expectation: check consistency rather than absolute time
-    const variance = maxDuration - minDuration;
-    const consistencyRatio = variance / avgDuration;
-
-    // Ensure reasonable performance (generous limit for CI environments)
-    expect(avgDuration).toBeLessThan(2000); // Very generous limit
-
-    // Ensure consistency across runs (variance should not be too high)
-    // More tolerant in CI environments where performance can be variable
-    const maxConsistencyRatio = process.env.CI ? 3.0 : 1.5;
-    expect(consistencyRatio).toBeLessThan(maxConsistencyRatio); // Max variance should be reasonable
-
-    console.log(
-      `✅ Performance test passed: avg=${avgDuration.toFixed(2)}ms, consistency=${(consistencyRatio * 100).toFixed(1)}% (threshold: ${(maxConsistencyRatio * 100).toFixed(0)}%)`,
-    );
+    // Verify we found the exact files we created
+    expect(result.length).toBe(numTargetDirs * numFilesPerDir);
+    expect(result.sort()).toEqual(expectedFiles.sort());
   });
 });

From 9bc0a4aff3136ae9bb16a03e4d14ba46a137141a Mon Sep 17 00:00:00 2001
From: Richie Foreman <richie.foreman@gmail.com>
Date: Thu, 7 Aug 2025 18:50:48 -0400
Subject: [PATCH 049/107] chore(telemetry): Log `FIREBASE_STUDIO` when using
 Gemini CLI within Firebase Studio (#5790)

---
 .../clearcut-logger/clearcut-logger.ts        | 24 +++++++++++++++----
 1 file changed, 20 insertions(+), 4 deletions(-)

diff --git a/packages/core/src/telemetry/clearcut-logger/clearcut-logger.ts b/packages/core/src/telemetry/clearcut-logger/clearcut-logger.ts
index 649d82b6..45a657c7 100644
--- a/packages/core/src/telemetry/clearcut-logger/clearcut-logger.ts
+++ b/packages/core/src/telemetry/clearcut-logger/clearcut-logger.ts
@@ -51,6 +51,25 @@ export interface LogResponse {
   nextRequestWaitMs?: number;
 }
 
+/**
+ * Determine the surface that the user is currently using.  Surface is effectively the
+ * distribution channel in which the user is using Gemini CLI.  Gemini CLI comes bundled
+ * w/ Firebase Studio and Cloud Shell.  Users that manually download themselves will
+ * likely be "SURFACE_NOT_SET".
+ *
+ * This is computed based upon a series of environment variables these distribution
+ * methods might have in their runtimes.
+ */
+function determineSurface(): string {
+  if (process.env.CLOUD_SHELL === 'true') {
+    return 'CLOUD_SHELL';
+  } else if (process.env.MONOSPACE_ENV === 'true') {
+    return 'FIREBASE_STUDIO';
+  } else {
+    return process.env.SURFACE || 'SURFACE_NOT_SET';
+  }
+}
+
 // Singleton class for batch posting log events to Clearcut. When a new event comes in, the elapsed time
 // is checked and events are flushed to Clearcut if at least a minute has passed since the last flush.
 export class ClearcutLogger {
@@ -237,10 +256,7 @@ export class ClearcutLogger {
   }
 
   logStartSessionEvent(event: StartSessionEvent): void {
-    const surface =
-      process.env.CLOUD_SHELL === 'true'
-        ? 'CLOUD_SHELL'
-        : process.env.SURFACE || 'SURFACE_NOT_SET';
+    const surface = determineSurface();
 
     const data = [
       {

From 65e4b941ee96525895b5a11fcb95725817478775 Mon Sep 17 00:00:00 2001
From: Richie Foreman <richie.foreman@gmail.com>
Date: Thu, 7 Aug 2025 18:54:00 -0400
Subject: [PATCH 050/107] chore(vscode): Add recommended extensions list to
 vscode settings. (#5810)

---
 .vscode/extensions.json | 3 +++
 1 file changed, 3 insertions(+)
 create mode 100644 .vscode/extensions.json

diff --git a/.vscode/extensions.json b/.vscode/extensions.json
new file mode 100644
index 00000000..183356b0
--- /dev/null
+++ b/.vscode/extensions.json
@@ -0,0 +1,3 @@
+{
+  "recommendations": ["vitest.explorer", "esbenp.prettier-vscode"]
+}

From 4f2974dbfe36638915f1b08448d2563c64f88644 Mon Sep 17 00:00:00 2001
From: Gal Zahavi <38544478+galz10@users.noreply.github.com>
Date: Thu, 7 Aug 2025 15:55:53 -0700
Subject: [PATCH 051/107] feat(ui): Improve UI layout adaptation for narrow
 terminals (#5651)

Co-authored-by: Jacob Richman <jacob314@gmail.com>
---
 packages/cli/src/ui/App.test.tsx              |  29 +++
 packages/cli/src/ui/App.tsx                   |  15 +-
 .../src/ui/__snapshots__/App.test.tsx.snap    |  17 +-
 packages/cli/src/ui/components/AsciiArt.ts    |  11 ++
 .../components/ContextSummaryDisplay.test.tsx |  85 +++++++++
 .../ui/components/ContextSummaryDisplay.tsx   |  54 +++---
 .../cli/src/ui/components/Footer.test.tsx     | 106 +++++++++++
 packages/cli/src/ui/components/Footer.tsx     | 167 ++++++++++--------
 .../cli/src/ui/components/Header.test.tsx     |  44 +++++
 packages/cli/src/ui/components/Header.tsx     |  22 ++-
 .../cli/src/ui/components/InputPrompt.tsx     |   4 +-
 .../ui/components/LoadingIndicator.test.tsx   |  70 ++++++++
 .../src/ui/components/LoadingIndicator.tsx    |  57 ++++--
 .../src/ui/components/SuggestionsDisplay.tsx  |   2 +-
 packages/cli/src/ui/utils/isNarrowWidth.ts    |   9 +
 15 files changed, 560 insertions(+), 132 deletions(-)
 create mode 100644 packages/cli/src/ui/components/ContextSummaryDisplay.test.tsx
 create mode 100644 packages/cli/src/ui/components/Footer.test.tsx
 create mode 100644 packages/cli/src/ui/components/Header.test.tsx
 create mode 100644 packages/cli/src/ui/utils/isNarrowWidth.ts

diff --git a/packages/cli/src/ui/App.test.tsx b/packages/cli/src/ui/App.test.tsx
index a5c2a9c6..577133ca 100644
--- a/packages/cli/src/ui/App.test.tsx
+++ b/packages/cli/src/ui/App.test.tsx
@@ -28,6 +28,7 @@ import { checkForUpdates, UpdateObject } from './utils/updateCheck.js';
 import { EventEmitter } from 'events';
 import { updateEventEmitter } from '../utils/updateEventEmitter.js';
 import * as auth from '../config/auth.js';
+import * as useTerminalSize from './hooks/useTerminalSize.js';
 
 // Define a more complete mock server config based on actual Config
 interface MockServerConfig {
@@ -243,6 +244,10 @@ vi.mock('../config/auth.js', () => ({
   validateAuthMethod: vi.fn(),
 }));
 
+vi.mock('../hooks/useTerminalSize.js', () => ({
+  useTerminalSize: vi.fn(),
+}));
+
 const mockedCheckForUpdates = vi.mocked(checkForUpdates);
 const { isGitRepository: mockedIsGitRepository } = vi.mocked(
   await import('@google/gemini-cli-core'),
@@ -284,6 +289,11 @@ describe('App UI', () => {
   };
 
   beforeEach(() => {
+    vi.spyOn(useTerminalSize, 'useTerminalSize').mockReturnValue({
+      columns: 120,
+      rows: 24,
+    });
+
     const ServerConfigMocked = vi.mocked(ServerConfig, true);
     mockConfig = new ServerConfigMocked({
       embeddingModel: 'test-embedding-model',
@@ -1062,4 +1072,23 @@ describe('App UI', () => {
       expect(validateAuthMethodSpy).not.toHaveBeenCalled();
     });
   });
+
+  describe('when in a narrow terminal', () => {
+    it('should render with a column layout', () => {
+      vi.spyOn(useTerminalSize, 'useTerminalSize').mockReturnValue({
+        columns: 60,
+        rows: 24,
+      });
+
+      const { lastFrame, unmount } = render(
+        <App
+          config={mockConfig as unknown as ServerConfig}
+          settings={mockSettings}
+          version={mockVersion}
+        />,
+      );
+      currentUnmount = unmount;
+      expect(lastFrame()).toMatchSnapshot();
+    });
+  });
 });
diff --git a/packages/cli/src/ui/App.tsx b/packages/cli/src/ui/App.tsx
index d311facf..a25b7a56 100644
--- a/packages/cli/src/ui/App.tsx
+++ b/packages/cli/src/ui/App.tsx
@@ -93,6 +93,7 @@ import { ShowMoreLines } from './components/ShowMoreLines.js';
 import { PrivacyNotice } from './privacy/PrivacyNotice.js';
 import { setUpdateHandler } from '../utils/handleAutoUpdate.js';
 import { appEvents, AppEvent } from '../utils/events.js';
+import { isNarrowWidth } from './utils/isNarrowWidth.js';
 
 const CTRL_EXIT_PROMPT_DURATION_MS = 1000;
 
@@ -433,6 +434,7 @@ const App = ({ config, settings, startupWarnings = [], version }: AppProps) => {
 
   // Terminal and UI setup
   const { rows: terminalHeight, columns: terminalWidth } = useTerminalSize();
+  const isNarrow = isNarrowWidth(terminalWidth);
   const { stdin, setRawMode } = useStdin();
   const isInitialMount = useRef(true);
 
@@ -441,7 +443,7 @@ const App = ({ config, settings, startupWarnings = [], version }: AppProps) => {
     20,
     Math.floor(terminalWidth * widthFraction) - 3,
   );
-  const suggestionsWidth = Math.max(60, Math.floor(terminalWidth * 0.8));
+  const suggestionsWidth = Math.max(20, Math.floor(terminalWidth * 0.8));
 
   // Utility callbacks
   const isValidPath = useCallback((filePath: string): boolean => {
@@ -835,11 +837,7 @@ const App = ({ config, settings, startupWarnings = [], version }: AppProps) => {
           items={[
             <Box flexDirection="column" key="header">
               {!settings.merged.hideBanner && (
-                <Header
-                  terminalWidth={terminalWidth}
-                  version={version}
-                  nightly={nightly}
-                />
+                <Header version={version} nightly={nightly} />
               )}
               {!settings.merged.hideTips && <Tips config={config} />}
             </Box>,
@@ -994,9 +992,10 @@ const App = ({ config, settings, startupWarnings = [], version }: AppProps) => {
 
               <Box
                 marginTop={1}
-                display="flex"
                 justifyContent="space-between"
                 width="100%"
+                flexDirection={isNarrow ? 'column' : 'row'}
+                alignItems={isNarrow ? 'flex-start' : 'center'}
               >
                 <Box>
                   {process.env.GEMINI_SYSTEM_MD && (
@@ -1021,7 +1020,7 @@ const App = ({ config, settings, startupWarnings = [], version }: AppProps) => {
                     />
                   )}
                 </Box>
-                <Box>
+                <Box paddingTop={isNarrow ? 1 : 0}>
                   {showAutoAcceptIndicator !== ApprovalMode.DEFAULT &&
                     !shellModeActive && (
                       <AutoAcceptIndicator
diff --git a/packages/cli/src/ui/__snapshots__/App.test.tsx.snap b/packages/cli/src/ui/__snapshots__/App.test.tsx.snap
index 891a16af..f5425dba 100644
--- a/packages/cli/src/ui/__snapshots__/App.test.tsx.snap
+++ b/packages/cli/src/ui/__snapshots__/App.test.tsx.snap
@@ -10,9 +10,22 @@ exports[`App UI > should render correctly with the prompt input box 1`] = `
 `;
 
 exports[`App UI > should render the initial UI correctly 1`] = `
-"
- I'm Feeling Lucky (esc to cancel, 0s)
+" I'm Feeling Lucky (esc to cancel, 0s)
 
 
 /test/dir                no sandbox (see /docs)                  model (100% context left)"
 `;
+
+exports[`App UI > when in a narrow terminal > should render with a column layout 1`] = `
+"
+
+
+╭────────────────────────────────────────────────────────────────────────────────────────╮
+│ >   Type your message or @path/to/file                                                 │
+╰────────────────────────────────────────────────────────────────────────────────────────╯
+dir
+
+no sandbox (see /docs)
+
+model (100% context left)| ✖ 5 errors (ctrl+o for details)"
+`;
diff --git a/packages/cli/src/ui/components/AsciiArt.ts b/packages/cli/src/ui/components/AsciiArt.ts
index e15704dd..79eb522c 100644
--- a/packages/cli/src/ui/components/AsciiArt.ts
+++ b/packages/cli/src/ui/components/AsciiArt.ts
@@ -25,3 +25,14 @@ export const longAsciiLogo = `
  ███░         ░░█████████  ██████████ █████     █████ █████ █████  ░░█████ █████
 ░░░            ░░░░░░░░░  ░░░░░░░░░░ ░░░░░     ░░░░░ ░░░░░ ░░░░░    ░░░░░ ░░░░░
 `;
+
+export const tinyAsciiLogo = `
+ ███         █████████ 
+░░░███      ███░░░░░███
+  ░░░███   ███     ░░░ 
+    ░░░███░███         
+     ███░ ░███    █████
+   ███░   ░░███  ░░███ 
+ ███░      ░░█████████ 
+░░░         ░░░░░░░░░  
+`;
diff --git a/packages/cli/src/ui/components/ContextSummaryDisplay.test.tsx b/packages/cli/src/ui/components/ContextSummaryDisplay.test.tsx
new file mode 100644
index 00000000..d70bb4ca
--- /dev/null
+++ b/packages/cli/src/ui/components/ContextSummaryDisplay.test.tsx
@@ -0,0 +1,85 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import React from 'react';
+import { render } from 'ink-testing-library';
+import { describe, it, expect, vi } from 'vitest';
+import { ContextSummaryDisplay } from './ContextSummaryDisplay.js';
+import * as useTerminalSize from '../hooks/useTerminalSize.js';
+
+vi.mock('../hooks/useTerminalSize.js', () => ({
+  useTerminalSize: vi.fn(),
+}));
+
+const useTerminalSizeMock = vi.mocked(useTerminalSize.useTerminalSize);
+
+const renderWithWidth = (
+  width: number,
+  props: React.ComponentProps<typeof ContextSummaryDisplay>,
+) => {
+  useTerminalSizeMock.mockReturnValue({ columns: width, rows: 24 });
+  return render(<ContextSummaryDisplay {...props} />);
+};
+
+describe('<ContextSummaryDisplay />', () => {
+  const baseProps = {
+    geminiMdFileCount: 1,
+    contextFileNames: ['GEMINI.md'],
+    mcpServers: { 'test-server': { command: 'test' } },
+    showToolDescriptions: false,
+    ideContext: {
+      workspaceState: {
+        openFiles: [{ path: '/a/b/c' }],
+      },
+    },
+  };
+
+  it('should render on a single line on a wide screen', () => {
+    const { lastFrame } = renderWithWidth(120, baseProps);
+    const output = lastFrame();
+    expect(output).toContain(
+      'Using: 1 open file (ctrl+e to view) | 1 GEMINI.md file | 1 MCP server (ctrl+t to view)',
+    );
+    // Check for absence of newlines
+    expect(output.includes('\n')).toBe(false);
+  });
+
+  it('should render on multiple lines on a narrow screen', () => {
+    const { lastFrame } = renderWithWidth(60, baseProps);
+    const output = lastFrame();
+    const expectedLines = [
+      'Using:',
+      '  - 1 open file (ctrl+e to view)',
+      '  - 1 GEMINI.md file',
+      '  - 1 MCP server (ctrl+t to view)',
+    ];
+    const actualLines = output.split('\n');
+    expect(actualLines).toEqual(expectedLines);
+  });
+
+  it('should switch layout at the 80-column breakpoint', () => {
+    // At 80 columns, should be on one line
+    const { lastFrame: wideFrame } = renderWithWidth(80, baseProps);
+    expect(wideFrame().includes('\n')).toBe(false);
+
+    // At 79 columns, should be on multiple lines
+    const { lastFrame: narrowFrame } = renderWithWidth(79, baseProps);
+    expect(narrowFrame().includes('\n')).toBe(true);
+    expect(narrowFrame().split('\n').length).toBe(4);
+  });
+
+  it('should not render empty parts', () => {
+    const props = {
+      ...baseProps,
+      geminiMdFileCount: 0,
+      mcpServers: {},
+    };
+    const { lastFrame } = renderWithWidth(60, props);
+    const expectedLines = ['Using:', '  - 1 open file (ctrl+e to view)'];
+    const actualLines = lastFrame().split('\n');
+    expect(actualLines).toEqual(expectedLines);
+  });
+});
diff --git a/packages/cli/src/ui/components/ContextSummaryDisplay.tsx b/packages/cli/src/ui/components/ContextSummaryDisplay.tsx
index 78a19f0d..99406bd6 100644
--- a/packages/cli/src/ui/components/ContextSummaryDisplay.tsx
+++ b/packages/cli/src/ui/components/ContextSummaryDisplay.tsx
@@ -5,9 +5,11 @@
  */
 
 import React from 'react';
-import { Text } from 'ink';
+import { Box, Text } from 'ink';
 import { Colors } from '../colors.js';
 import { type IdeContext, type MCPServerConfig } from '@google/gemini-cli-core';
+import { useTerminalSize } from '../hooks/useTerminalSize.js';
+import { isNarrowWidth } from '../utils/isNarrowWidth.js';
 
 interface ContextSummaryDisplayProps {
   geminiMdFileCount: number;
@@ -26,6 +28,8 @@ export const ContextSummaryDisplay: React.FC<ContextSummaryDisplayProps> = ({
   showToolDescriptions,
   ideContext,
 }) => {
+  const { columns: terminalWidth } = useTerminalSize();
+  const isNarrow = isNarrowWidth(terminalWidth);
   const mcpServerCount = Object.keys(mcpServers || {}).length;
   const blockedMcpServerCount = blockedMcpServers?.length || 0;
   const openFileCount = ideContext?.workspaceState?.openFiles?.length ?? 0;
@@ -78,30 +82,36 @@ export const ContextSummaryDisplay: React.FC<ContextSummaryDisplayProps> = ({
       }
       parts.push(blockedText);
     }
-    return parts.join(', ');
+    let text = parts.join(', ');
+    // Add ctrl+t hint when MCP servers are available
+    if (mcpServers && Object.keys(mcpServers).length > 0) {
+      if (showToolDescriptions) {
+        text += ' (ctrl+t to toggle)';
+      } else {
+        text += ' (ctrl+t to view)';
+      }
+    }
+    return text;
   })();
 
-  let summaryText = 'Using: ';
-  const summaryParts = [];
-  if (openFilesText) {
-    summaryParts.push(openFilesText);
-  }
-  if (geminiMdText) {
-    summaryParts.push(geminiMdText);
-  }
-  if (mcpText) {
-    summaryParts.push(mcpText);
-  }
-  summaryText += summaryParts.join(' | ');
+  const summaryParts = [openFilesText, geminiMdText, mcpText].filter(Boolean);
 
-  // Add ctrl+t hint when MCP servers are available
-  if (mcpServers && Object.keys(mcpServers).length > 0) {
-    if (showToolDescriptions) {
-      summaryText += ' (ctrl+t to toggle)';
-    } else {
-      summaryText += ' (ctrl+t to view)';
-    }
+  if (isNarrow) {
+    return (
+      <Box flexDirection="column">
+        <Text color={Colors.Gray}>Using:</Text>
+        {summaryParts.map((part, index) => (
+          <Text key={index} color={Colors.Gray}>
+            {'  '}- {part}
+          </Text>
+        ))}
+      </Box>
+    );
   }
 
-  return <Text color={Colors.Gray}>{summaryText}</Text>;
+  return (
+    <Box>
+      <Text color={Colors.Gray}>Using: {summaryParts.join(' | ')}</Text>
+    </Box>
+  );
 };
diff --git a/packages/cli/src/ui/components/Footer.test.tsx b/packages/cli/src/ui/components/Footer.test.tsx
new file mode 100644
index 00000000..5e79eea4
--- /dev/null
+++ b/packages/cli/src/ui/components/Footer.test.tsx
@@ -0,0 +1,106 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { render } from 'ink-testing-library';
+import { describe, it, expect, vi } from 'vitest';
+import { Footer } from './Footer.js';
+import * as useTerminalSize from '../hooks/useTerminalSize.js';
+import { tildeifyPath } from '@google/gemini-cli-core';
+import path from 'node:path';
+
+vi.mock('../hooks/useTerminalSize.js');
+const useTerminalSizeMock = vi.mocked(useTerminalSize.useTerminalSize);
+
+vi.mock('@google/gemini-cli-core', async (importOriginal) => {
+  const original =
+    await importOriginal<typeof import('@google/gemini-cli-core')>();
+  return {
+    ...original,
+    shortenPath: (p: string, len: number) => {
+      if (p.length > len) {
+        return '...' + p.slice(p.length - len + 3);
+      }
+      return p;
+    },
+  };
+});
+
+const defaultProps = {
+  model: 'gemini-pro',
+  targetDir:
+    '/Users/test/project/foo/bar/and/some/more/directories/to/make/it/long',
+  branchName: 'main',
+  debugMode: false,
+  debugMessage: '',
+  corgiMode: false,
+  errorCount: 0,
+  showErrorDetails: false,
+  showMemoryUsage: false,
+  promptTokenCount: 100,
+  nightly: false,
+};
+
+const renderWithWidth = (width: number, props = defaultProps) => {
+  useTerminalSizeMock.mockReturnValue({ columns: width, rows: 24 });
+  return render(<Footer {...props} />);
+};
+
+describe('<Footer />', () => {
+  it('renders the component', () => {
+    const { lastFrame } = renderWithWidth(120);
+    expect(lastFrame()).toBeDefined();
+  });
+
+  describe('path display', () => {
+    it('should display shortened path on a wide terminal', () => {
+      const { lastFrame } = renderWithWidth(120);
+      const tildePath = tildeifyPath(defaultProps.targetDir);
+      const expectedPath = '...' + tildePath.slice(tildePath.length - 48 + 3);
+      expect(lastFrame()).toContain(expectedPath);
+    });
+
+    it('should display only the base directory name on a narrow terminal', () => {
+      const { lastFrame } = renderWithWidth(79);
+      const expectedPath = path.basename(defaultProps.targetDir);
+      expect(lastFrame()).toContain(expectedPath);
+    });
+
+    it('should use wide layout at 80 columns', () => {
+      const { lastFrame } = renderWithWidth(80);
+      const tildePath = tildeifyPath(defaultProps.targetDir);
+      const expectedPath = '...' + tildePath.slice(tildePath.length - 32 + 3);
+      expect(lastFrame()).toContain(expectedPath);
+    });
+
+    it('should use narrow layout at 79 columns', () => {
+      const { lastFrame } = renderWithWidth(79);
+      const expectedPath = path.basename(defaultProps.targetDir);
+      expect(lastFrame()).toContain(expectedPath);
+      const tildePath = tildeifyPath(defaultProps.targetDir);
+      const unexpectedPath = '...' + tildePath.slice(tildePath.length - 31 + 3);
+      expect(lastFrame()).not.toContain(unexpectedPath);
+    });
+  });
+
+  it('displays the branch name when provided', () => {
+    const { lastFrame } = renderWithWidth(120);
+    expect(lastFrame()).toContain(`(${defaultProps.branchName}*)`);
+  });
+
+  it('does not display the branch name when not provided', () => {
+    const { lastFrame } = renderWithWidth(120, {
+      ...defaultProps,
+      branchName: undefined,
+    });
+    expect(lastFrame()).not.toContain(`(${defaultProps.branchName}*)`);
+  });
+
+  it('displays the model name and context percentage', () => {
+    const { lastFrame } = renderWithWidth(120);
+    expect(lastFrame()).toContain(defaultProps.model);
+    expect(lastFrame()).toMatch(/\(\d+% context[\s\S]*left\)/);
+  });
+});
diff --git a/packages/cli/src/ui/components/Footer.tsx b/packages/cli/src/ui/components/Footer.tsx
index 14cda5f3..7de47659 100644
--- a/packages/cli/src/ui/components/Footer.tsx
+++ b/packages/cli/src/ui/components/Footer.tsx
@@ -10,11 +10,15 @@ import { Colors } from '../colors.js';
 import { shortenPath, tildeifyPath } from '@google/gemini-cli-core';
 import { ConsoleSummaryDisplay } from './ConsoleSummaryDisplay.js';
 import process from 'node:process';
+import path from 'node:path';
 import Gradient from 'ink-gradient';
 import { MemoryUsageDisplay } from './MemoryUsageDisplay.js';
 import { ContextUsageDisplay } from './ContextUsageDisplay.js';
 import { DebugProfiler } from './DebugProfiler.js';
 
+import { useTerminalSize } from '../hooks/useTerminalSize.js';
+import { isNarrowWidth } from '../utils/isNarrowWidth.js';
+
 interface FooterProps {
   model: string;
   targetDir: string;
@@ -43,81 +47,100 @@ export const Footer: React.FC<FooterProps> = ({
   promptTokenCount,
   nightly,
   vimMode,
-}) => (
-  <Box justifyContent="space-between" width="100%">
-    <Box>
-      {debugMode && <DebugProfiler />}
-      {vimMode && <Text color={Colors.Gray}>[{vimMode}] </Text>}
-      {nightly ? (
-        <Gradient colors={Colors.GradientColors}>
-          <Text>
-            {shortenPath(tildeifyPath(targetDir), 70)}
-            {branchName && <Text> ({branchName}*)</Text>}
-          </Text>
-        </Gradient>
-      ) : (
-        <Text color={Colors.LightBlue}>
-          {shortenPath(tildeifyPath(targetDir), 70)}
-          {branchName && <Text color={Colors.Gray}> ({branchName}*)</Text>}
-        </Text>
-      )}
-      {debugMode && (
-        <Text color={Colors.AccentRed}>
-          {' ' + (debugMessage || '--debug')}
-        </Text>
-      )}
-    </Box>
+}) => {
+  const { columns: terminalWidth } = useTerminalSize();
 
-    {/* Middle Section: Centered Sandbox Info */}
+  const isNarrow = isNarrowWidth(terminalWidth);
+
+  // Adjust path length based on terminal width
+  const pathLength = Math.max(20, Math.floor(terminalWidth * 0.4));
+  const displayPath = isNarrow
+    ? path.basename(tildeifyPath(targetDir))
+    : shortenPath(tildeifyPath(targetDir), pathLength);
+
+  return (
     <Box
-      flexGrow={1}
-      alignItems="center"
-      justifyContent="center"
-      display="flex"
+      justifyContent="space-between"
+      width="100%"
+      flexDirection={isNarrow ? 'column' : 'row'}
+      alignItems={isNarrow ? 'flex-start' : 'center'}
     >
-      {process.env.SANDBOX && process.env.SANDBOX !== 'sandbox-exec' ? (
-        <Text color="green">
-          {process.env.SANDBOX.replace(/^gemini-(?:cli-)?/, '')}
-        </Text>
-      ) : process.env.SANDBOX === 'sandbox-exec' ? (
-        <Text color={Colors.AccentYellow}>
-          macOS Seatbelt{' '}
-          <Text color={Colors.Gray}>({process.env.SEATBELT_PROFILE})</Text>
-        </Text>
-      ) : (
-        <Text color={Colors.AccentRed}>
-          no sandbox <Text color={Colors.Gray}>(see /docs)</Text>
-        </Text>
-      )}
-    </Box>
+      <Box>
+        {debugMode && <DebugProfiler />}
+        {vimMode && <Text color={Colors.Gray}>[{vimMode}] </Text>}
+        {nightly ? (
+          <Gradient colors={Colors.GradientColors}>
+            <Text>
+              {displayPath}
+              {branchName && <Text> ({branchName}*)</Text>}
+            </Text>
+          </Gradient>
+        ) : (
+          <Text color={Colors.LightBlue}>
+            {displayPath}
+            {branchName && <Text color={Colors.Gray}> ({branchName}*)</Text>}
+          </Text>
+        )}
+        {debugMode && (
+          <Text color={Colors.AccentRed}>
+            {' ' + (debugMessage || '--debug')}
+          </Text>
+        )}
+      </Box>
 
-    {/* Right Section: Gemini Label and Console Summary */}
-    <Box alignItems="center">
-      <Text color={Colors.AccentBlue}>
-        {' '}
-        {model}{' '}
-        <ContextUsageDisplay
-          promptTokenCount={promptTokenCount}
-          model={model}
-        />
-      </Text>
-      {corgiMode && (
-        <Text>
-          <Text color={Colors.Gray}>| </Text>
-          <Text color={Colors.AccentRed}>▼</Text>
-          <Text color={Colors.Foreground}>(´</Text>
-          <Text color={Colors.AccentRed}>ᴥ</Text>
-          <Text color={Colors.Foreground}>`)</Text>
-          <Text color={Colors.AccentRed}>▼ </Text>
+      {/* Middle Section: Centered Sandbox Info */}
+      <Box
+        flexGrow={isNarrow ? 0 : 1}
+        alignItems="center"
+        justifyContent={isNarrow ? 'flex-start' : 'center'}
+        display="flex"
+        paddingX={isNarrow ? 0 : 1}
+        paddingTop={isNarrow ? 1 : 0}
+      >
+        {process.env.SANDBOX && process.env.SANDBOX !== 'sandbox-exec' ? (
+          <Text color="green">
+            {process.env.SANDBOX.replace(/^gemini-(?:cli-)?/, '')}
+          </Text>
+        ) : process.env.SANDBOX === 'sandbox-exec' ? (
+          <Text color={Colors.AccentYellow}>
+            macOS Seatbelt{' '}
+            <Text color={Colors.Gray}>({process.env.SEATBELT_PROFILE})</Text>
+          </Text>
+        ) : (
+          <Text color={Colors.AccentRed}>
+            no sandbox <Text color={Colors.Gray}>(see /docs)</Text>
+          </Text>
+        )}
+      </Box>
+
+      {/* Right Section: Gemini Label and Console Summary */}
+      <Box alignItems="center" paddingTop={isNarrow ? 1 : 0}>
+        <Text color={Colors.AccentBlue}>
+          {isNarrow ? '' : ' '}
+          {model}{' '}
+          <ContextUsageDisplay
+            promptTokenCount={promptTokenCount}
+            model={model}
+          />
         </Text>
-      )}
-      {!showErrorDetails && errorCount > 0 && (
-        <Box>
-          <Text color={Colors.Gray}>| </Text>
-          <ConsoleSummaryDisplay errorCount={errorCount} />
-        </Box>
-      )}
-      {showMemoryUsage && <MemoryUsageDisplay />}
+        {corgiMode && (
+          <Text>
+            <Text color={Colors.Gray}>| </Text>
+            <Text color={Colors.AccentRed}>▼</Text>
+            <Text color={Colors.Foreground}>(´</Text>
+            <Text color={Colors.AccentRed}>ᴥ</Text>
+            <Text color={Colors.Foreground}>`)</Text>
+            <Text color={Colors.AccentRed}>▼ </Text>
+          </Text>
+        )}
+        {!showErrorDetails && errorCount > 0 && (
+          <Box>
+            <Text color={Colors.Gray}>| </Text>
+            <ConsoleSummaryDisplay errorCount={errorCount} />
+          </Box>
+        )}
+        {showMemoryUsage && <MemoryUsageDisplay />}
+      </Box>
     </Box>
-  </Box>
-);
+  );
+};
diff --git a/packages/cli/src/ui/components/Header.test.tsx b/packages/cli/src/ui/components/Header.test.tsx
new file mode 100644
index 00000000..95ed3f07
--- /dev/null
+++ b/packages/cli/src/ui/components/Header.test.tsx
@@ -0,0 +1,44 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { render } from 'ink-testing-library';
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { Header } from './Header.js';
+import * as useTerminalSize from '../hooks/useTerminalSize.js';
+import { longAsciiLogo } from './AsciiArt.js';
+
+vi.mock('../hooks/useTerminalSize.js');
+
+describe('<Header />', () => {
+  beforeEach(() => {});
+
+  it('renders the long logo on a wide terminal', () => {
+    vi.spyOn(useTerminalSize, 'useTerminalSize').mockReturnValue({
+      columns: 120,
+      rows: 20,
+    });
+    const { lastFrame } = render(<Header version="1.0.0" nightly={false} />);
+    expect(lastFrame()).toContain(longAsciiLogo);
+  });
+
+  it('renders custom ASCII art when provided', () => {
+    const customArt = 'CUSTOM ART';
+    const { lastFrame } = render(
+      <Header version="1.0.0" nightly={false} customAsciiArt={customArt} />,
+    );
+    expect(lastFrame()).toContain(customArt);
+  });
+
+  it('displays the version number when nightly is true', () => {
+    const { lastFrame } = render(<Header version="1.0.0" nightly={true} />);
+    expect(lastFrame()).toContain('v1.0.0');
+  });
+
+  it('does not display the version number when nightly is false', () => {
+    const { lastFrame } = render(<Header version="1.0.0" nightly={false} />);
+    expect(lastFrame()).not.toContain('v1.0.0');
+  });
+});
diff --git a/packages/cli/src/ui/components/Header.tsx b/packages/cli/src/ui/components/Header.tsx
index 4038e415..0894ad14 100644
--- a/packages/cli/src/ui/components/Header.tsx
+++ b/packages/cli/src/ui/components/Header.tsx
@@ -8,30 +8,34 @@ import React from 'react';
 import { Box, Text } from 'ink';
 import Gradient from 'ink-gradient';
 import { Colors } from '../colors.js';
-import { shortAsciiLogo, longAsciiLogo } from './AsciiArt.js';
+import { shortAsciiLogo, longAsciiLogo, tinyAsciiLogo } from './AsciiArt.js';
 import { getAsciiArtWidth } from '../utils/textUtils.js';
+import { useTerminalSize } from '../hooks/useTerminalSize.js';
 
 interface HeaderProps {
   customAsciiArt?: string; // For user-defined ASCII art
-  terminalWidth: number; // For responsive logo
   version: string;
   nightly: boolean;
 }
 
 export const Header: React.FC<HeaderProps> = ({
   customAsciiArt,
-  terminalWidth,
   version,
   nightly,
 }) => {
+  const { columns: terminalWidth } = useTerminalSize();
   let displayTitle;
   const widthOfLongLogo = getAsciiArtWidth(longAsciiLogo);
+  const widthOfShortLogo = getAsciiArtWidth(shortAsciiLogo);
 
   if (customAsciiArt) {
     displayTitle = customAsciiArt;
+  } else if (terminalWidth >= widthOfLongLogo) {
+    displayTitle = longAsciiLogo;
+  } else if (terminalWidth >= widthOfShortLogo) {
+    displayTitle = shortAsciiLogo;
   } else {
-    displayTitle =
-      terminalWidth >= widthOfLongLogo ? longAsciiLogo : shortAsciiLogo;
+    displayTitle = tinyAsciiLogo;
   }
 
   const artWidth = getAsciiArtWidth(displayTitle);
@@ -52,9 +56,13 @@ export const Header: React.FC<HeaderProps> = ({
       )}
       {nightly && (
         <Box width="100%" flexDirection="row" justifyContent="flex-end">
-          <Gradient colors={Colors.GradientColors}>
+          {Colors.GradientColors ? (
+            <Gradient colors={Colors.GradientColors}>
+              <Text>v{version}</Text>
+            </Gradient>
+          ) : (
             <Text>v{version}</Text>
-          </Gradient>
+          )}
         </Box>
       )}
     </Box>
diff --git a/packages/cli/src/ui/components/InputPrompt.tsx b/packages/cli/src/ui/components/InputPrompt.tsx
index b405b684..7a7a9934 100644
--- a/packages/cli/src/ui/components/InputPrompt.tsx
+++ b/packages/cli/src/ui/components/InputPrompt.tsx
@@ -536,7 +536,7 @@ export const InputPrompt: React.FC<InputPromptProps> = ({
         </Box>
       </Box>
       {completion.showSuggestions && (
-        <Box>
+        <Box paddingRight={2}>
           <SuggestionsDisplay
             suggestions={completion.suggestions}
             activeIndex={completion.activeSuggestionIndex}
@@ -548,7 +548,7 @@ export const InputPrompt: React.FC<InputPromptProps> = ({
         </Box>
       )}
       {reverseSearchActive && (
-        <Box>
+        <Box paddingRight={2}>
           <SuggestionsDisplay
             suggestions={reverseSearchCompletion.suggestions}
             activeIndex={reverseSearchCompletion.activeSuggestionIndex}
diff --git a/packages/cli/src/ui/components/LoadingIndicator.test.tsx b/packages/cli/src/ui/components/LoadingIndicator.test.tsx
index 9e647208..e55cc090 100644
--- a/packages/cli/src/ui/components/LoadingIndicator.test.tsx
+++ b/packages/cli/src/ui/components/LoadingIndicator.test.tsx
@@ -11,6 +11,7 @@ import { LoadingIndicator } from './LoadingIndicator.js';
 import { StreamingContext } from '../contexts/StreamingContext.js';
 import { StreamingState } from '../types.js';
 import { vi } from 'vitest';
+import * as useTerminalSize from '../hooks/useTerminalSize.js';
 
 // Mock GeminiRespondingSpinner
 vi.mock('./GeminiRespondingSpinner.js', () => ({
@@ -29,10 +30,18 @@ vi.mock('./GeminiRespondingSpinner.js', () => ({
   },
 }));
 
+vi.mock('../hooks/useTerminalSize.js', () => ({
+  useTerminalSize: vi.fn(),
+}));
+
+const useTerminalSizeMock = vi.mocked(useTerminalSize.useTerminalSize);
+
 const renderWithContext = (
   ui: React.ReactElement,
   streamingStateValue: StreamingState,
+  width = 120,
 ) => {
+  useTerminalSizeMock.mockReturnValue({ columns: width, rows: 24 });
   const contextValue: StreamingState = streamingStateValue;
   return render(
     <StreamingContext.Provider value={contextValue}>
@@ -223,4 +232,65 @@ describe('<LoadingIndicator />', () => {
     expect(output).toContain('This should be displayed');
     expect(output).not.toContain('This should not be displayed');
   });
+
+  describe('responsive layout', () => {
+    it('should render on a single line on a wide terminal', () => {
+      const { lastFrame } = renderWithContext(
+        <LoadingIndicator
+          {...defaultProps}
+          rightContent={<Text>Right</Text>}
+        />,
+        StreamingState.Responding,
+        120,
+      );
+      const output = lastFrame();
+      // Check for single line output
+      expect(output?.includes('\n')).toBe(false);
+      expect(output).toContain('Loading...');
+      expect(output).toContain('(esc to cancel, 5s)');
+      expect(output).toContain('Right');
+    });
+
+    it('should render on multiple lines on a narrow terminal', () => {
+      const { lastFrame } = renderWithContext(
+        <LoadingIndicator
+          {...defaultProps}
+          rightContent={<Text>Right</Text>}
+        />,
+        StreamingState.Responding,
+        79,
+      );
+      const output = lastFrame();
+      const lines = output?.split('\n');
+      // Expecting 3 lines:
+      // 1. Spinner + Primary Text
+      // 2. Cancel + Timer
+      // 3. Right Content
+      expect(lines).toHaveLength(3);
+      if (lines) {
+        expect(lines[0]).toContain('Loading...');
+        expect(lines[0]).not.toContain('(esc to cancel, 5s)');
+        expect(lines[1]).toContain('(esc to cancel, 5s)');
+        expect(lines[2]).toContain('Right');
+      }
+    });
+
+    it('should use wide layout at 80 columns', () => {
+      const { lastFrame } = renderWithContext(
+        <LoadingIndicator {...defaultProps} />,
+        StreamingState.Responding,
+        80,
+      );
+      expect(lastFrame()?.includes('\n')).toBe(false);
+    });
+
+    it('should use narrow layout at 79 columns', () => {
+      const { lastFrame } = renderWithContext(
+        <LoadingIndicator {...defaultProps} />,
+        StreamingState.Responding,
+        79,
+      );
+      expect(lastFrame()?.includes('\n')).toBe(true);
+    });
+  });
 });
diff --git a/packages/cli/src/ui/components/LoadingIndicator.tsx b/packages/cli/src/ui/components/LoadingIndicator.tsx
index 6e1bc758..7ac356dd 100644
--- a/packages/cli/src/ui/components/LoadingIndicator.tsx
+++ b/packages/cli/src/ui/components/LoadingIndicator.tsx
@@ -12,6 +12,8 @@ import { useStreamingContext } from '../contexts/StreamingContext.js';
 import { StreamingState } from '../types.js';
 import { GeminiRespondingSpinner } from './GeminiRespondingSpinner.js';
 import { formatDuration } from '../utils/formatters.js';
+import { useTerminalSize } from '../hooks/useTerminalSize.js';
+import { isNarrowWidth } from '../utils/isNarrowWidth.js';
 
 interface LoadingIndicatorProps {
   currentLoadingPhrase?: string;
@@ -27,6 +29,8 @@ export const LoadingIndicator: React.FC<LoadingIndicatorProps> = ({
   thought,
 }) => {
   const streamingState = useStreamingContext();
+  const { columns: terminalWidth } = useTerminalSize();
+  const isNarrow = isNarrowWidth(terminalWidth);
 
   if (streamingState === StreamingState.Idle) {
     return null;
@@ -34,28 +38,45 @@ export const LoadingIndicator: React.FC<LoadingIndicatorProps> = ({
 
   const primaryText = thought?.subject || currentLoadingPhrase;
 
+  const cancelAndTimerContent =
+    streamingState !== StreamingState.WaitingForConfirmation
+      ? `(esc to cancel, ${elapsedTime < 60 ? `${elapsedTime}s` : formatDuration(elapsedTime * 1000)})`
+      : null;
+
   return (
-    <Box marginTop={1} paddingLeft={0} flexDirection="column">
+    <Box paddingLeft={0} flexDirection="column">
       {/* Main loading line */}
-      <Box>
-        <Box marginRight={1}>
-          <GeminiRespondingSpinner
-            nonRespondingDisplay={
-              streamingState === StreamingState.WaitingForConfirmation
-                ? '⠏'
-                : ''
-            }
-          />
+      <Box
+        width="100%"
+        flexDirection={isNarrow ? 'column' : 'row'}
+        alignItems={isNarrow ? 'flex-start' : 'center'}
+      >
+        <Box>
+          <Box marginRight={1}>
+            <GeminiRespondingSpinner
+              nonRespondingDisplay={
+                streamingState === StreamingState.WaitingForConfirmation
+                  ? '⠏'
+                  : ''
+              }
+            />
+          </Box>
+          {primaryText && (
+            <Text color={Colors.AccentPurple}>{primaryText}</Text>
+          )}
+          {!isNarrow && cancelAndTimerContent && (
+            <Text color={Colors.Gray}> {cancelAndTimerContent}</Text>
+          )}
         </Box>
-        {primaryText && <Text color={Colors.AccentPurple}>{primaryText}</Text>}
-        <Text color={Colors.Gray}>
-          {streamingState === StreamingState.WaitingForConfirmation
-            ? ''
-            : ` (esc to cancel, ${elapsedTime < 60 ? `${elapsedTime}s` : formatDuration(elapsedTime * 1000)})`}
-        </Text>
-        <Box flexGrow={1}>{/* Spacer */}</Box>
-        {rightContent && <Box>{rightContent}</Box>}
+        {!isNarrow && <Box flexGrow={1}>{/* Spacer */}</Box>}
+        {!isNarrow && rightContent && <Box>{rightContent}</Box>}
       </Box>
+      {isNarrow && cancelAndTimerContent && (
+        <Box>
+          <Text color={Colors.Gray}>{cancelAndTimerContent}</Text>
+        </Box>
+      )}
+      {isNarrow && rightContent && <Box>{rightContent}</Box>}
     </Box>
   );
 };
diff --git a/packages/cli/src/ui/components/SuggestionsDisplay.tsx b/packages/cli/src/ui/components/SuggestionsDisplay.tsx
index 9c4b5687..1275a911 100644
--- a/packages/cli/src/ui/components/SuggestionsDisplay.tsx
+++ b/packages/cli/src/ui/components/SuggestionsDisplay.tsx
@@ -82,7 +82,7 @@ export function SuggestionsDisplay({
               )}
               {suggestion.description ? (
                 <Box flexGrow={1}>
-                  <Text color={textColor} wrap="wrap">
+                  <Text color={textColor} wrap="truncate">
                     {suggestion.description}
                   </Text>
                 </Box>
diff --git a/packages/cli/src/ui/utils/isNarrowWidth.ts b/packages/cli/src/ui/utils/isNarrowWidth.ts
new file mode 100644
index 00000000..5540a400
--- /dev/null
+++ b/packages/cli/src/ui/utils/isNarrowWidth.ts
@@ -0,0 +1,9 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+export function isNarrowWidth(width: number): boolean {
+  return width < 80;
+}

From 785ee5d59a60df89413d8f0dd1b7916279f6e786 Mon Sep 17 00:00:00 2001
From: Miguel Solorio <miguelsolorio@google.com>
Date: Thu, 7 Aug 2025 16:11:35 -0700
Subject: [PATCH 052/107] Use semantic colors in themes (#5796)

Co-authored-by: Jacob Richman <jacob314@gmail.com>
---
 packages/cli/src/ui/components/Footer.tsx     |  40 +--
 .../cli/src/ui/components/InputPrompt.tsx     |  14 +-
 packages/cli/src/ui/semantic-colors.ts        |  26 ++
 packages/cli/src/ui/themes/ansi-light.ts      |   2 +
 packages/cli/src/ui/themes/ansi.ts            |   2 +
 packages/cli/src/ui/themes/atom-one-dark.ts   |   2 +
 packages/cli/src/ui/themes/ayu-light.ts       |   2 +
 packages/cli/src/ui/themes/ayu.ts             |   2 +
 packages/cli/src/ui/themes/default-light.ts   |   2 +
 packages/cli/src/ui/themes/default.ts         |   2 +
 packages/cli/src/ui/themes/dracula.ts         |   2 +
 packages/cli/src/ui/themes/github-dark.ts     |   2 +
 packages/cli/src/ui/themes/github-light.ts    |   2 +
 packages/cli/src/ui/themes/googlecode.ts      |   2 +
 packages/cli/src/ui/themes/no-color.ts        |  32 +++
 packages/cli/src/ui/themes/semantic-tokens.ts | 127 +++++++++
 .../cli/src/ui/themes/shades-of-purple.ts     |   2 +
 .../cli/src/ui/themes/theme-manager.test.ts   |   9 -
 packages/cli/src/ui/themes/theme-manager.ts   |   9 +
 packages/cli/src/ui/themes/theme.test.ts      |  50 ----
 packages/cli/src/ui/themes/theme.ts           | 261 ++++++++++--------
 packages/cli/src/ui/themes/xcode.ts           |   2 +
 22 files changed, 396 insertions(+), 198 deletions(-)
 create mode 100644 packages/cli/src/ui/semantic-colors.ts
 create mode 100644 packages/cli/src/ui/themes/semantic-tokens.ts

diff --git a/packages/cli/src/ui/components/Footer.tsx b/packages/cli/src/ui/components/Footer.tsx
index 7de47659..aaf6c176 100644
--- a/packages/cli/src/ui/components/Footer.tsx
+++ b/packages/cli/src/ui/components/Footer.tsx
@@ -6,7 +6,7 @@
 
 import React from 'react';
 import { Box, Text } from 'ink';
-import { Colors } from '../colors.js';
+import { theme } from '../semantic-colors.js';
 import { shortenPath, tildeifyPath } from '@google/gemini-cli-core';
 import { ConsoleSummaryDisplay } from './ConsoleSummaryDisplay.js';
 import process from 'node:process';
@@ -67,22 +67,24 @@ export const Footer: React.FC<FooterProps> = ({
     >
       <Box>
         {debugMode && <DebugProfiler />}
-        {vimMode && <Text color={Colors.Gray}>[{vimMode}] </Text>}
+        {vimMode && <Text color={theme.text.secondary}>[{vimMode}] </Text>}
         {nightly ? (
-          <Gradient colors={Colors.GradientColors}>
+          <Gradient colors={theme.ui.gradient}>
             <Text>
               {displayPath}
               {branchName && <Text> ({branchName}*)</Text>}
             </Text>
           </Gradient>
         ) : (
-          <Text color={Colors.LightBlue}>
+          <Text color={theme.text.link}>
             {displayPath}
-            {branchName && <Text color={Colors.Gray}> ({branchName}*)</Text>}
+            {branchName && (
+              <Text color={theme.text.secondary}> ({branchName}*)</Text>
+            )}
           </Text>
         )}
         {debugMode && (
-          <Text color={Colors.AccentRed}>
+          <Text color={theme.status.error}>
             {' ' + (debugMessage || '--debug')}
           </Text>
         )}
@@ -102,20 +104,22 @@ export const Footer: React.FC<FooterProps> = ({
             {process.env.SANDBOX.replace(/^gemini-(?:cli-)?/, '')}
           </Text>
         ) : process.env.SANDBOX === 'sandbox-exec' ? (
-          <Text color={Colors.AccentYellow}>
+          <Text color={theme.status.warning}>
             macOS Seatbelt{' '}
-            <Text color={Colors.Gray}>({process.env.SEATBELT_PROFILE})</Text>
+            <Text color={theme.text.secondary}>
+              ({process.env.SEATBELT_PROFILE})
+            </Text>
           </Text>
         ) : (
-          <Text color={Colors.AccentRed}>
-            no sandbox <Text color={Colors.Gray}>(see /docs)</Text>
+          <Text color={theme.status.error}>
+            no sandbox <Text color={theme.text.secondary}>(see /docs)</Text>
           </Text>
         )}
       </Box>
 
       {/* Right Section: Gemini Label and Console Summary */}
       <Box alignItems="center" paddingTop={isNarrow ? 1 : 0}>
-        <Text color={Colors.AccentBlue}>
+        <Text color={theme.text.accent}>
           {isNarrow ? '' : ' '}
           {model}{' '}
           <ContextUsageDisplay
@@ -125,17 +129,17 @@ export const Footer: React.FC<FooterProps> = ({
         </Text>
         {corgiMode && (
           <Text>
-            <Text color={Colors.Gray}>| </Text>
-            <Text color={Colors.AccentRed}>▼</Text>
-            <Text color={Colors.Foreground}>(´</Text>
-            <Text color={Colors.AccentRed}>ᴥ</Text>
-            <Text color={Colors.Foreground}>`)</Text>
-            <Text color={Colors.AccentRed}>▼ </Text>
+            <Text color={theme.ui.symbol}>| </Text>
+            <Text color={theme.status.error}>▼</Text>
+            <Text color={theme.text.primary}>(´</Text>
+            <Text color={theme.status.error}>ᴥ</Text>
+            <Text color={theme.text.primary}>`)</Text>
+            <Text color={theme.status.error}>▼ </Text>
           </Text>
         )}
         {!showErrorDetails && errorCount > 0 && (
           <Box>
-            <Text color={Colors.Gray}>| </Text>
+            <Text color={theme.ui.symbol}>| </Text>
             <ConsoleSummaryDisplay errorCount={errorCount} />
           </Box>
         )}
diff --git a/packages/cli/src/ui/components/InputPrompt.tsx b/packages/cli/src/ui/components/InputPrompt.tsx
index 7a7a9934..7250afea 100644
--- a/packages/cli/src/ui/components/InputPrompt.tsx
+++ b/packages/cli/src/ui/components/InputPrompt.tsx
@@ -6,7 +6,7 @@
 
 import React, { useCallback, useEffect, useState } from 'react';
 import { Box, Text } from 'ink';
-import { Colors } from '../colors.js';
+import { theme } from '../semantic-colors.js';
 import { SuggestionsDisplay } from './SuggestionsDisplay.js';
 import { useInputHistory } from '../hooks/useInputHistory.js';
 import { TextBuffer, logicalPosToOffset } from './shared/text-buffer.js';
@@ -469,15 +469,17 @@ export const InputPrompt: React.FC<InputPromptProps> = ({
     <>
       <Box
         borderStyle="round"
-        borderColor={shellModeActive ? Colors.AccentYellow : Colors.AccentBlue}
+        borderColor={
+          shellModeActive ? theme.status.warning : theme.border.focused
+        }
         paddingX={1}
       >
         <Text
-          color={shellModeActive ? Colors.AccentYellow : Colors.AccentPurple}
+          color={shellModeActive ? theme.status.warning : theme.text.accent}
         >
           {shellModeActive ? (
             reverseSearchActive ? (
-              <Text color={Colors.AccentCyan}>(r:) </Text>
+              <Text color={theme.text.link}>(r:) </Text>
             ) : (
               '! '
             )
@@ -490,10 +492,10 @@ export const InputPrompt: React.FC<InputPromptProps> = ({
             focus ? (
               <Text>
                 {chalk.inverse(placeholder.slice(0, 1))}
-                <Text color={Colors.Gray}>{placeholder.slice(1)}</Text>
+                <Text color={theme.text.secondary}>{placeholder.slice(1)}</Text>
               </Text>
             ) : (
-              <Text color={Colors.Gray}>{placeholder}</Text>
+              <Text color={theme.text.secondary}>{placeholder}</Text>
             )
           ) : (
             linesToRender.map((lineText, visualIdxInRenderedSet) => {
diff --git a/packages/cli/src/ui/semantic-colors.ts b/packages/cli/src/ui/semantic-colors.ts
new file mode 100644
index 00000000..98fba0fe
--- /dev/null
+++ b/packages/cli/src/ui/semantic-colors.ts
@@ -0,0 +1,26 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { themeManager } from './themes/theme-manager.js';
+import { SemanticColors } from './themes/semantic-tokens.js';
+
+export const theme: SemanticColors = {
+  get text() {
+    return themeManager.getSemanticColors().text;
+  },
+  get background() {
+    return themeManager.getSemanticColors().background;
+  },
+  get border() {
+    return themeManager.getSemanticColors().border;
+  },
+  get ui() {
+    return themeManager.getSemanticColors().ui;
+  },
+  get status() {
+    return themeManager.getSemanticColors().status;
+  },
+};
diff --git a/packages/cli/src/ui/themes/ansi-light.ts b/packages/cli/src/ui/themes/ansi-light.ts
index 00f9bbcc..8ccb65bd 100644
--- a/packages/cli/src/ui/themes/ansi-light.ts
+++ b/packages/cli/src/ui/themes/ansi-light.ts
@@ -5,6 +5,7 @@
  */
 
 import { type ColorsTheme, Theme } from './theme.js';
+import { lightSemanticColors } from './semantic-tokens.js';
 
 const ansiLightColors: ColorsTheme = {
   type: 'light',
@@ -145,4 +146,5 @@ export const ANSILight: Theme = new Theme(
     },
   },
   ansiLightColors,
+  lightSemanticColors,
 );
diff --git a/packages/cli/src/ui/themes/ansi.ts b/packages/cli/src/ui/themes/ansi.ts
index 2afc135c..21644813 100644
--- a/packages/cli/src/ui/themes/ansi.ts
+++ b/packages/cli/src/ui/themes/ansi.ts
@@ -5,6 +5,7 @@
  */
 
 import { type ColorsTheme, Theme } from './theme.js';
+import { darkSemanticColors } from './semantic-tokens.js';
 
 const ansiColors: ColorsTheme = {
   type: 'dark',
@@ -154,4 +155,5 @@ export const ANSI: Theme = new Theme(
     },
   },
   ansiColors,
+  darkSemanticColors,
 );
diff --git a/packages/cli/src/ui/themes/atom-one-dark.ts b/packages/cli/src/ui/themes/atom-one-dark.ts
index 5545971e..e5d76256 100644
--- a/packages/cli/src/ui/themes/atom-one-dark.ts
+++ b/packages/cli/src/ui/themes/atom-one-dark.ts
@@ -5,6 +5,7 @@
  */
 
 import { type ColorsTheme, Theme } from './theme.js';
+import { darkSemanticColors } from './semantic-tokens.js';
 
 const atomOneDarkColors: ColorsTheme = {
   type: 'dark',
@@ -142,4 +143,5 @@ export const AtomOneDark: Theme = new Theme(
     },
   },
   atomOneDarkColors,
+  darkSemanticColors,
 );
diff --git a/packages/cli/src/ui/themes/ayu-light.ts b/packages/cli/src/ui/themes/ayu-light.ts
index 8410cfb2..f96fbbf0 100644
--- a/packages/cli/src/ui/themes/ayu-light.ts
+++ b/packages/cli/src/ui/themes/ayu-light.ts
@@ -5,6 +5,7 @@
  */
 
 import { type ColorsTheme, Theme } from './theme.js';
+import { lightSemanticColors } from './semantic-tokens.js';
 
 const ayuLightColors: ColorsTheme = {
   type: 'light',
@@ -134,4 +135,5 @@ export const AyuLight: Theme = new Theme(
     },
   },
   ayuLightColors,
+  lightSemanticColors,
 );
diff --git a/packages/cli/src/ui/themes/ayu.ts b/packages/cli/src/ui/themes/ayu.ts
index 1d1fc7d0..1f2d247a 100644
--- a/packages/cli/src/ui/themes/ayu.ts
+++ b/packages/cli/src/ui/themes/ayu.ts
@@ -5,6 +5,7 @@
  */
 
 import { type ColorsTheme, Theme } from './theme.js';
+import { darkSemanticColors } from './semantic-tokens.js';
 
 const ayuDarkColors: ColorsTheme = {
   type: 'dark',
@@ -108,4 +109,5 @@ export const AyuDark: Theme = new Theme(
     },
   },
   ayuDarkColors,
+  darkSemanticColors,
 );
diff --git a/packages/cli/src/ui/themes/default-light.ts b/packages/cli/src/ui/themes/default-light.ts
index 1803e7fa..707648f1 100644
--- a/packages/cli/src/ui/themes/default-light.ts
+++ b/packages/cli/src/ui/themes/default-light.ts
@@ -5,6 +5,7 @@
  */
 
 import { lightTheme, Theme } from './theme.js';
+import { lightSemanticColors } from './semantic-tokens.js';
 
 export const DefaultLight: Theme = new Theme(
   'Default Light',
@@ -103,4 +104,5 @@ export const DefaultLight: Theme = new Theme(
     },
   },
   lightTheme,
+  lightSemanticColors,
 );
diff --git a/packages/cli/src/ui/themes/default.ts b/packages/cli/src/ui/themes/default.ts
index e1d0247c..d6662bf5 100644
--- a/packages/cli/src/ui/themes/default.ts
+++ b/packages/cli/src/ui/themes/default.ts
@@ -5,6 +5,7 @@
  */
 
 import { darkTheme, Theme } from './theme.js';
+import { darkSemanticColors } from './semantic-tokens.js';
 
 export const DefaultDark: Theme = new Theme(
   'Default',
@@ -146,4 +147,5 @@ export const DefaultDark: Theme = new Theme(
     },
   },
   darkTheme,
+  darkSemanticColors,
 );
diff --git a/packages/cli/src/ui/themes/dracula.ts b/packages/cli/src/ui/themes/dracula.ts
index e746d8e8..2def698e 100644
--- a/packages/cli/src/ui/themes/dracula.ts
+++ b/packages/cli/src/ui/themes/dracula.ts
@@ -5,6 +5,7 @@
  */
 
 import { type ColorsTheme, Theme } from './theme.js';
+import { darkSemanticColors } from './semantic-tokens.js';
 
 const draculaColors: ColorsTheme = {
   type: 'dark',
@@ -119,4 +120,5 @@ export const Dracula: Theme = new Theme(
     },
   },
   draculaColors,
+  darkSemanticColors,
 );
diff --git a/packages/cli/src/ui/themes/github-dark.ts b/packages/cli/src/ui/themes/github-dark.ts
index e93c8c6a..3fae630d 100644
--- a/packages/cli/src/ui/themes/github-dark.ts
+++ b/packages/cli/src/ui/themes/github-dark.ts
@@ -5,6 +5,7 @@
  */
 
 import { type ColorsTheme, Theme } from './theme.js';
+import { darkSemanticColors } from './semantic-tokens.js';
 
 const githubDarkColors: ColorsTheme = {
   type: 'dark',
@@ -142,4 +143,5 @@ export const GitHubDark: Theme = new Theme(
     },
   },
   githubDarkColors,
+  darkSemanticColors,
 );
diff --git a/packages/cli/src/ui/themes/github-light.ts b/packages/cli/src/ui/themes/github-light.ts
index dcb4bbf0..380559b9 100644
--- a/packages/cli/src/ui/themes/github-light.ts
+++ b/packages/cli/src/ui/themes/github-light.ts
@@ -5,6 +5,7 @@
  */
 
 import { type ColorsTheme, Theme } from './theme.js';
+import { lightSemanticColors } from './semantic-tokens.js';
 
 const githubLightColors: ColorsTheme = {
   type: 'light',
@@ -144,4 +145,5 @@ export const GitHubLight: Theme = new Theme(
     },
   },
   githubLightColors,
+  lightSemanticColors,
 );
diff --git a/packages/cli/src/ui/themes/googlecode.ts b/packages/cli/src/ui/themes/googlecode.ts
index 38b719a3..187f22fa 100644
--- a/packages/cli/src/ui/themes/googlecode.ts
+++ b/packages/cli/src/ui/themes/googlecode.ts
@@ -5,6 +5,7 @@
  */
 
 import { lightTheme, Theme, type ColorsTheme } from './theme.js';
+import { lightSemanticColors } from './semantic-tokens.js';
 
 const googleCodeColors: ColorsTheme = {
   type: 'light',
@@ -141,4 +142,5 @@ export const GoogleCode: Theme = new Theme(
     },
   },
   googleCodeColors,
+  lightSemanticColors,
 );
diff --git a/packages/cli/src/ui/themes/no-color.ts b/packages/cli/src/ui/themes/no-color.ts
index a6efb454..161b407e 100644
--- a/packages/cli/src/ui/themes/no-color.ts
+++ b/packages/cli/src/ui/themes/no-color.ts
@@ -5,6 +5,7 @@
  */
 
 import { Theme, ColorsTheme } from './theme.js';
+import { SemanticColors } from './semantic-tokens.js';
 
 const noColorColorsTheme: ColorsTheme = {
   type: 'ansi',
@@ -23,6 +24,36 @@ const noColorColorsTheme: ColorsTheme = {
   Gray: '',
 };
 
+const noColorSemanticColors: SemanticColors = {
+  text: {
+    primary: '',
+    secondary: '',
+    link: '',
+    accent: '',
+  },
+  background: {
+    primary: '',
+    diff: {
+      added: '',
+      removed: '',
+    },
+  },
+  border: {
+    default: '',
+    focused: '',
+  },
+  ui: {
+    comment: '',
+    symbol: '',
+    gradient: [],
+  },
+  status: {
+    error: '',
+    success: '',
+    warning: '',
+  },
+};
+
 export const NoColorTheme: Theme = new Theme(
   'NoColor',
   'dark',
@@ -90,4 +121,5 @@ export const NoColorTheme: Theme = new Theme(
     },
   },
   noColorColorsTheme,
+  noColorSemanticColors,
 );
diff --git a/packages/cli/src/ui/themes/semantic-tokens.ts b/packages/cli/src/ui/themes/semantic-tokens.ts
new file mode 100644
index 00000000..56430304
--- /dev/null
+++ b/packages/cli/src/ui/themes/semantic-tokens.ts
@@ -0,0 +1,127 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { lightTheme, darkTheme, ansiTheme } from './theme.js';
+
+export interface SemanticColors {
+  text: {
+    primary: string;
+    secondary: string;
+    link: string;
+    accent: string;
+  };
+  background: {
+    primary: string;
+    diff: {
+      added: string;
+      removed: string;
+    };
+  };
+  border: {
+    default: string;
+    focused: string;
+  };
+  ui: {
+    comment: string;
+    symbol: string;
+    gradient: string[] | undefined;
+  };
+  status: {
+    error: string;
+    success: string;
+    warning: string;
+  };
+}
+
+export const lightSemanticColors: SemanticColors = {
+  text: {
+    primary: lightTheme.Foreground,
+    secondary: lightTheme.Gray,
+    link: lightTheme.AccentBlue,
+    accent: lightTheme.AccentPurple,
+  },
+  background: {
+    primary: lightTheme.Background,
+    diff: {
+      added: lightTheme.DiffAdded,
+      removed: lightTheme.DiffRemoved,
+    },
+  },
+  border: {
+    default: lightTheme.Gray,
+    focused: lightTheme.AccentBlue,
+  },
+  ui: {
+    comment: lightTheme.Comment,
+    symbol: lightTheme.Gray,
+    gradient: lightTheme.GradientColors,
+  },
+  status: {
+    error: lightTheme.AccentRed,
+    success: lightTheme.AccentGreen,
+    warning: lightTheme.AccentYellow,
+  },
+};
+
+export const darkSemanticColors: SemanticColors = {
+  text: {
+    primary: darkTheme.Foreground,
+    secondary: darkTheme.Gray,
+    link: darkTheme.AccentBlue,
+    accent: darkTheme.AccentPurple,
+  },
+  background: {
+    primary: darkTheme.Background,
+    diff: {
+      added: darkTheme.DiffAdded,
+      removed: darkTheme.DiffRemoved,
+    },
+  },
+  border: {
+    default: darkTheme.Gray,
+    focused: darkTheme.AccentBlue,
+  },
+  ui: {
+    comment: darkTheme.Comment,
+    symbol: darkTheme.Gray,
+    gradient: darkTheme.GradientColors,
+  },
+  status: {
+    error: darkTheme.AccentRed,
+    success: darkTheme.AccentGreen,
+    warning: darkTheme.AccentYellow,
+  },
+};
+
+export const ansiSemanticColors: SemanticColors = {
+  text: {
+    primary: ansiTheme.Foreground,
+    secondary: ansiTheme.Gray,
+    link: ansiTheme.AccentBlue,
+    accent: ansiTheme.AccentPurple,
+  },
+  background: {
+    primary: ansiTheme.Background,
+    diff: {
+      added: ansiTheme.DiffAdded,
+      removed: ansiTheme.DiffRemoved,
+    },
+  },
+  border: {
+    default: ansiTheme.Gray,
+    focused: ansiTheme.AccentBlue,
+  },
+  ui: {
+    comment: ansiTheme.Comment,
+    symbol: ansiTheme.Gray,
+    gradient: ansiTheme.GradientColors,
+  },
+  status: {
+    error: ansiTheme.AccentRed,
+    success: ansiTheme.AccentGreen,
+    warning: ansiTheme.AccentYellow,
+  },
+};
diff --git a/packages/cli/src/ui/themes/shades-of-purple.ts b/packages/cli/src/ui/themes/shades-of-purple.ts
index 6e20240f..289bdee9 100644
--- a/packages/cli/src/ui/themes/shades-of-purple.ts
+++ b/packages/cli/src/ui/themes/shades-of-purple.ts
@@ -9,6 +9,7 @@
  * @author Ahmad Awais <https://twitter.com/mrahmadawais/>
  */
 import { type ColorsTheme, Theme } from './theme.js';
+import { darkSemanticColors } from './semantic-tokens.js';
 
 const shadesOfPurpleColors: ColorsTheme = {
   type: 'dark',
@@ -347,4 +348,5 @@ export const ShadesOfPurple = new Theme(
     },
   },
   shadesOfPurpleColors,
+  darkSemanticColors,
 );
diff --git a/packages/cli/src/ui/themes/theme-manager.test.ts b/packages/cli/src/ui/themes/theme-manager.test.ts
index 6f9565a5..0b2c17c0 100644
--- a/packages/cli/src/ui/themes/theme-manager.test.ts
+++ b/packages/cli/src/ui/themes/theme-manager.test.ts
@@ -44,15 +44,6 @@ describe('ThemeManager', () => {
     expect(themeManager.isCustomTheme('MyCustomTheme')).toBe(true);
   });
 
-  it('should not load invalid custom themes', () => {
-    const invalidTheme = { ...validCustomTheme, Background: 'not-a-color' };
-    themeManager.loadCustomThemes({
-      InvalidTheme: invalidTheme as unknown as CustomTheme,
-    });
-    expect(themeManager.getCustomThemeNames()).not.toContain('InvalidTheme');
-    expect(themeManager.isCustomTheme('InvalidTheme')).toBe(false);
-  });
-
   it('should set and get the active theme', () => {
     expect(themeManager.getActiveTheme().name).toBe(DEFAULT_THEME.name);
     themeManager.setActiveTheme('Ayu');
diff --git a/packages/cli/src/ui/themes/theme-manager.ts b/packages/cli/src/ui/themes/theme-manager.ts
index e30c1cce..b19b06a9 100644
--- a/packages/cli/src/ui/themes/theme-manager.ts
+++ b/packages/cli/src/ui/themes/theme-manager.ts
@@ -22,6 +22,7 @@ import {
   createCustomTheme,
   validateCustomTheme,
 } from './theme.js';
+import { SemanticColors } from './semantic-tokens.js';
 import { ANSI } from './ansi.js';
 import { ANSILight } from './ansi-light.js';
 import { NoColorTheme } from './no-color.js';
@@ -134,6 +135,14 @@ class ThemeManager {
     return this.activeTheme;
   }
 
+  /**
+   * Gets the semantic colors for the active theme.
+   * @returns The semantic colors.
+   */
+  getSemanticColors(): SemanticColors {
+    return this.getActiveTheme().semanticColors;
+  }
+
   /**
    * Gets a list of custom theme names.
    * @returns Array of custom theme names.
diff --git a/packages/cli/src/ui/themes/theme.test.ts b/packages/cli/src/ui/themes/theme.test.ts
index c1e4dc00..6359a922 100644
--- a/packages/cli/src/ui/themes/theme.test.ts
+++ b/packages/cli/src/ui/themes/theme.test.ts
@@ -36,25 +36,6 @@ describe('validateCustomTheme', () => {
     expect(result.error).toBeUndefined();
   });
 
-  it('should return isValid: false for a theme with a missing required field', () => {
-    const invalidTheme = {
-      ...validTheme,
-      name: undefined as unknown as string,
-    };
-    const result = validateCustomTheme(invalidTheme);
-    expect(result.isValid).toBe(false);
-    expect(result.error).toBe('Missing required field: name');
-  });
-
-  it('should return isValid: false for a theme with an invalid color format', () => {
-    const invalidTheme = { ...validTheme, Background: 'not-a-color' };
-    const result = validateCustomTheme(invalidTheme);
-    expect(result.isValid).toBe(false);
-    expect(result.error).toBe(
-      'Invalid color format for Background: not-a-color',
-    );
-  });
-
   it('should return isValid: false for a theme with an invalid name', () => {
     const invalidTheme = { ...validTheme, name: ' ' };
     const result = validateCustomTheme(invalidTheme);
@@ -71,37 +52,6 @@ describe('validateCustomTheme', () => {
     expect(result.error).toBeUndefined();
   });
 
-  it('should return a warning if DiffAdded and DiffRemoved are missing', () => {
-    const legacyTheme: Partial<CustomTheme> = { ...validTheme };
-    delete legacyTheme.DiffAdded;
-    delete legacyTheme.DiffRemoved;
-    const result = validateCustomTheme(legacyTheme);
-    expect(result.isValid).toBe(true);
-    expect(result.warning).toBe('Missing field(s) DiffAdded, DiffRemoved');
-  });
-
-  it('should return a warning if only DiffRemoved is missing', () => {
-    const legacyTheme: Partial<CustomTheme> = { ...validTheme };
-    delete legacyTheme.DiffRemoved;
-    const result = validateCustomTheme(legacyTheme);
-    expect(result.isValid).toBe(true);
-    expect(result.warning).toBe('Missing field(s) DiffRemoved');
-  });
-
-  it('should return isValid: false for a theme with an invalid DiffAdded color', () => {
-    const invalidTheme = { ...validTheme, DiffAdded: 'invalid' };
-    const result = validateCustomTheme(invalidTheme);
-    expect(result.isValid).toBe(false);
-    expect(result.error).toBe('Invalid color format for DiffAdded: invalid');
-  });
-
-  it('should return isValid: false for a theme with an invalid DiffRemoved color', () => {
-    const invalidTheme = { ...validTheme, DiffRemoved: 'invalid' };
-    const result = validateCustomTheme(invalidTheme);
-    expect(result.isValid).toBe(false);
-    expect(result.error).toBe('Invalid color format for DiffRemoved: invalid');
-  });
-
   it('should return isValid: false for a theme with a very long name', () => {
     const invalidTheme = { ...validTheme, name: 'a'.repeat(51) };
     const result = validateCustomTheme(invalidTheme);
diff --git a/packages/cli/src/ui/themes/theme.ts b/packages/cli/src/ui/themes/theme.ts
index 7d21af1d..e46c7f48 100644
--- a/packages/cli/src/ui/themes/theme.ts
+++ b/packages/cli/src/ui/themes/theme.ts
@@ -5,7 +5,8 @@
  */
 
 import type { CSSProperties } from 'react';
-import { isValidColor, resolveColor } from './color-utils.js';
+import { SemanticColors } from './semantic-tokens.js';
+import { resolveColor } from './color-utils.js';
 
 export type ThemeType = 'light' | 'dark' | 'ansi' | 'custom';
 
@@ -27,9 +28,53 @@ export interface ColorsTheme {
   GradientColors?: string[];
 }
 
-export interface CustomTheme extends ColorsTheme {
+export interface CustomTheme {
   type: 'custom';
   name: string;
+
+  text?: {
+    primary?: string;
+    secondary?: string;
+    link?: string;
+    accent?: string;
+  };
+  background?: {
+    primary?: string;
+    diff?: {
+      added?: string;
+      removed?: string;
+    };
+  };
+  border?: {
+    default?: string;
+    focused?: string;
+  };
+  ui?: {
+    comment?: string;
+    symbol?: string;
+    gradient?: string[];
+  };
+  status?: {
+    error?: string;
+    success?: string;
+    warning?: string;
+  };
+
+  // Legacy properties (all optional)
+  Background?: string;
+  Foreground?: string;
+  LightBlue?: string;
+  AccentBlue?: string;
+  AccentPurple?: string;
+  AccentCyan?: string;
+  AccentGreen?: string;
+  AccentYellow?: string;
+  AccentRed?: string;
+  DiffAdded?: string;
+  DiffRemoved?: string;
+  Comment?: string;
+  Gray?: string;
+  GradientColors?: string[];
 }
 
 export const lightTheme: ColorsTheme = {
@@ -107,6 +152,7 @@ export class Theme {
     readonly type: ThemeType,
     rawMappings: Record<string, CSSProperties>,
     readonly colors: ColorsTheme,
+    readonly semanticColors: SemanticColors,
   ) {
     this._colorMap = Object.freeze(this._buildColorMap(rawMappings)); // Build and freeze the map
 
@@ -174,107 +220,127 @@ export class Theme {
  * @returns A new Theme instance.
  */
 export function createCustomTheme(customTheme: CustomTheme): Theme {
+  const colors: ColorsTheme = {
+    type: 'custom',
+    Background: customTheme.background?.primary ?? customTheme.Background ?? '',
+    Foreground: customTheme.text?.primary ?? customTheme.Foreground ?? '',
+    LightBlue: customTheme.text?.link ?? customTheme.LightBlue ?? '',
+    AccentBlue: customTheme.text?.link ?? customTheme.AccentBlue ?? '',
+    AccentPurple: customTheme.text?.accent ?? customTheme.AccentPurple ?? '',
+    AccentCyan: customTheme.text?.link ?? customTheme.AccentCyan ?? '',
+    AccentGreen: customTheme.status?.success ?? customTheme.AccentGreen ?? '',
+    AccentYellow: customTheme.status?.warning ?? customTheme.AccentYellow ?? '',
+    AccentRed: customTheme.status?.error ?? customTheme.AccentRed ?? '',
+    DiffAdded:
+      customTheme.background?.diff?.added ?? customTheme.DiffAdded ?? '',
+    DiffRemoved:
+      customTheme.background?.diff?.removed ?? customTheme.DiffRemoved ?? '',
+    Comment: customTheme.ui?.comment ?? customTheme.Comment ?? '',
+    Gray: customTheme.text?.secondary ?? customTheme.Gray ?? '',
+    GradientColors: customTheme.ui?.gradient ?? customTheme.GradientColors,
+  };
+
   // Generate CSS properties mappings based on the custom theme colors
   const rawMappings: Record<string, CSSProperties> = {
     hljs: {
       display: 'block',
       overflowX: 'auto',
       padding: '0.5em',
-      background: customTheme.Background,
-      color: customTheme.Foreground,
+      background: colors.Background,
+      color: colors.Foreground,
     },
     'hljs-keyword': {
-      color: customTheme.AccentBlue,
+      color: colors.AccentBlue,
     },
     'hljs-literal': {
-      color: customTheme.AccentBlue,
+      color: colors.AccentBlue,
     },
     'hljs-symbol': {
-      color: customTheme.AccentBlue,
+      color: colors.AccentBlue,
     },
     'hljs-name': {
-      color: customTheme.AccentBlue,
+      color: colors.AccentBlue,
     },
     'hljs-link': {
-      color: customTheme.AccentBlue,
+      color: colors.AccentBlue,
       textDecoration: 'underline',
     },
     'hljs-built_in': {
-      color: customTheme.AccentCyan,
+      color: colors.AccentCyan,
     },
     'hljs-type': {
-      color: customTheme.AccentCyan,
+      color: colors.AccentCyan,
     },
     'hljs-number': {
-      color: customTheme.AccentGreen,
+      color: colors.AccentGreen,
     },
     'hljs-class': {
-      color: customTheme.AccentGreen,
+      color: colors.AccentGreen,
     },
     'hljs-string': {
-      color: customTheme.AccentYellow,
+      color: colors.AccentYellow,
     },
     'hljs-meta-string': {
-      color: customTheme.AccentYellow,
+      color: colors.AccentYellow,
     },
     'hljs-regexp': {
-      color: customTheme.AccentRed,
+      color: colors.AccentRed,
     },
     'hljs-template-tag': {
-      color: customTheme.AccentRed,
+      color: colors.AccentRed,
     },
     'hljs-subst': {
-      color: customTheme.Foreground,
+      color: colors.Foreground,
     },
     'hljs-function': {
-      color: customTheme.Foreground,
+      color: colors.Foreground,
     },
     'hljs-title': {
-      color: customTheme.Foreground,
+      color: colors.Foreground,
     },
     'hljs-params': {
-      color: customTheme.Foreground,
+      color: colors.Foreground,
     },
     'hljs-formula': {
-      color: customTheme.Foreground,
+      color: colors.Foreground,
     },
     'hljs-comment': {
-      color: customTheme.Comment,
+      color: colors.Comment,
       fontStyle: 'italic',
     },
     'hljs-quote': {
-      color: customTheme.Comment,
+      color: colors.Comment,
       fontStyle: 'italic',
     },
     'hljs-doctag': {
-      color: customTheme.Comment,
+      color: colors.Comment,
     },
     'hljs-meta': {
-      color: customTheme.Gray,
+      color: colors.Gray,
     },
     'hljs-meta-keyword': {
-      color: customTheme.Gray,
+      color: colors.Gray,
     },
     'hljs-tag': {
-      color: customTheme.Gray,
+      color: colors.Gray,
     },
     'hljs-variable': {
-      color: customTheme.AccentPurple,
+      color: colors.AccentPurple,
     },
     'hljs-template-variable': {
-      color: customTheme.AccentPurple,
+      color: colors.AccentPurple,
     },
     'hljs-attr': {
-      color: customTheme.LightBlue,
+      color: colors.LightBlue,
     },
     'hljs-attribute': {
-      color: customTheme.LightBlue,
+      color: colors.LightBlue,
     },
     'hljs-builtin-name': {
-      color: customTheme.LightBlue,
+      color: colors.LightBlue,
     },
     'hljs-section': {
-      color: customTheme.AccentYellow,
+      color: colors.AccentYellow,
     },
     'hljs-emphasis': {
       fontStyle: 'italic',
@@ -283,36 +349,72 @@ export function createCustomTheme(customTheme: CustomTheme): Theme {
       fontWeight: 'bold',
     },
     'hljs-bullet': {
-      color: customTheme.AccentYellow,
+      color: colors.AccentYellow,
     },
     'hljs-selector-tag': {
-      color: customTheme.AccentYellow,
+      color: colors.AccentYellow,
     },
     'hljs-selector-id': {
-      color: customTheme.AccentYellow,
+      color: colors.AccentYellow,
     },
     'hljs-selector-class': {
-      color: customTheme.AccentYellow,
+      color: colors.AccentYellow,
     },
     'hljs-selector-attr': {
-      color: customTheme.AccentYellow,
+      color: colors.AccentYellow,
     },
     'hljs-selector-pseudo': {
-      color: customTheme.AccentYellow,
+      color: colors.AccentYellow,
     },
     'hljs-addition': {
-      backgroundColor: customTheme.AccentGreen,
+      backgroundColor: colors.AccentGreen,
       display: 'inline-block',
       width: '100%',
     },
     'hljs-deletion': {
-      backgroundColor: customTheme.AccentRed,
+      backgroundColor: colors.AccentRed,
       display: 'inline-block',
       width: '100%',
     },
   };
 
-  return new Theme(customTheme.name, 'custom', rawMappings, customTheme);
+  const semanticColors: SemanticColors = {
+    text: {
+      primary: colors.Foreground,
+      secondary: colors.Gray,
+      link: colors.AccentBlue,
+      accent: colors.AccentPurple,
+    },
+    background: {
+      primary: colors.Background,
+      diff: {
+        added: colors.DiffAdded,
+        removed: colors.DiffRemoved,
+      },
+    },
+    border: {
+      default: colors.Gray,
+      focused: colors.AccentBlue,
+    },
+    ui: {
+      comment: colors.Comment,
+      symbol: colors.Gray,
+      gradient: colors.GradientColors,
+    },
+    status: {
+      error: colors.AccentRed,
+      success: colors.AccentGreen,
+      warning: colors.AccentYellow,
+    },
+  };
+
+  return new Theme(
+    customTheme.name,
+    'custom',
+    rawMappings,
+    colors,
+    semanticColors,
+  );
 }
 
 /**
@@ -325,74 +427,7 @@ export function validateCustomTheme(customTheme: Partial<CustomTheme>): {
   error?: string;
   warning?: string;
 } {
-  // Check required fields
-  const requiredFields: Array<keyof CustomTheme> = [
-    'name',
-    'Background',
-    'Foreground',
-    'LightBlue',
-    'AccentBlue',
-    'AccentPurple',
-    'AccentCyan',
-    'AccentGreen',
-    'AccentYellow',
-    'AccentRed',
-    // 'DiffAdded' and 'DiffRemoved' are not required as they were added after
-    // the theme format was defined.
-    'Comment',
-    'Gray',
-  ];
-
-  const recommendedFields: Array<keyof CustomTheme> = [
-    'DiffAdded',
-    'DiffRemoved',
-  ];
-
-  for (const field of requiredFields) {
-    if (!customTheme[field]) {
-      return {
-        isValid: false,
-        error: `Missing required field: ${field}`,
-      };
-    }
-  }
-
-  const missingFields: string[] = [];
-
-  for (const field of recommendedFields) {
-    if (!customTheme[field]) {
-      missingFields.push(field);
-    }
-  }
-
-  // Validate color format (basic hex validation)
-  const colorFields: Array<keyof CustomTheme> = [
-    'Background',
-    'Foreground',
-    'LightBlue',
-    'AccentBlue',
-    'AccentPurple',
-    'AccentCyan',
-    'AccentGreen',
-    'AccentYellow',
-    'AccentRed',
-    'DiffAdded',
-    'DiffRemoved',
-    'Comment',
-    'Gray',
-  ];
-
-  for (const field of colorFields) {
-    const color = customTheme[field] as string | undefined;
-    if (color !== undefined && !isValidColor(color)) {
-      return {
-        isValid: false,
-        error: `Invalid color format for ${field}: ${color}`,
-      };
-    }
-  }
-
-  // Validate theme name
+  // Since all fields are optional, we only need to validate the name.
   if (customTheme.name && !isValidThemeName(customTheme.name)) {
     return {
       isValid: false,
@@ -402,10 +437,6 @@ export function validateCustomTheme(customTheme: Partial<CustomTheme>): {
 
   return {
     isValid: true,
-    warning:
-      missingFields.length > 0
-        ? `Missing field(s) ${missingFields.join(', ')}`
-        : undefined,
   };
 }
 
diff --git a/packages/cli/src/ui/themes/xcode.ts b/packages/cli/src/ui/themes/xcode.ts
index 690d2386..6c150007 100644
--- a/packages/cli/src/ui/themes/xcode.ts
+++ b/packages/cli/src/ui/themes/xcode.ts
@@ -5,6 +5,7 @@
  */
 
 import { type ColorsTheme, Theme } from './theme.js';
+import { lightSemanticColors } from './semantic-tokens.js';
 
 const xcodeColors: ColorsTheme = {
   type: 'light',
@@ -149,4 +150,5 @@ export const XCode: Theme = new Theme(
     },
   },
   xcodeColors,
+  lightSemanticColors,
 );

From 494a10e7a7d31233f5d8cb0db1235bd432421d87 Mon Sep 17 00:00:00 2001
From: Jerop Kipruto <jerop@google.com>
Date: Fri, 8 Aug 2025 08:14:28 +0900
Subject: [PATCH 053/107] Add echo tool to automated triage workflow (#5809)

Co-authored-by: Gaurav <39389231+gsquared94@users.noreply.github.com>
---
 .github/workflows/gemini-automated-issue-triage.yml | 1 +
 1 file changed, 1 insertion(+)

diff --git a/.github/workflows/gemini-automated-issue-triage.yml b/.github/workflows/gemini-automated-issue-triage.yml
index c9381833..74904d4c 100644
--- a/.github/workflows/gemini-automated-issue-triage.yml
+++ b/.github/workflows/gemini-automated-issue-triage.yml
@@ -75,6 +75,7 @@ jobs:
             {
               "maxSessionTurns": 25,
               "coreTools": [
+                "run_shell_command(echo)",
                 "run_shell_command(gh label list)",
                 "run_shell_command(gh issue edit)",
                 "run_shell_command(gh issue list)"

From 60362e0329febb8811f37d7f68f00843dd51e1ed Mon Sep 17 00:00:00 2001
From: laurentsimon <64505099+laurentsimon@users.noreply.github.com>
Date: Thu, 7 Aug 2025 16:42:17 -0700
Subject: [PATCH 054/107] fix: MCP servers allowed in settings do not show up
 in /mcp command (#5324)

---
 packages/cli/src/config/config.ts | 71 ++++++++++++++++++-------------
 1 file changed, 42 insertions(+), 29 deletions(-)

diff --git a/packages/cli/src/config/config.ts b/packages/cli/src/config/config.ts
index d142bd12..400d7432 100644
--- a/packages/cli/src/config/config.ts
+++ b/packages/cli/src/config/config.ts
@@ -26,6 +26,7 @@ import {
   ShellTool,
   EditTool,
   WriteFileTool,
+  MCPServerConfig,
 } from '@google/gemini-cli-core';
 import { Settings } from './settings.js';
 
@@ -388,12 +389,11 @@ export async function loadCliConfig(
 
   if (!argv.allowedMcpServerNames) {
     if (settings.allowMCPServers) {
-      const allowedNames = new Set(settings.allowMCPServers.filter(Boolean));
-      if (allowedNames.size > 0) {
-        mcpServers = Object.fromEntries(
-          Object.entries(mcpServers).filter(([key]) => allowedNames.has(key)),
-        );
-      }
+      mcpServers = allowedMcpServers(
+        mcpServers,
+        settings.allowMCPServers,
+        blockedMcpServers,
+      );
     }
 
     if (settings.excludeMCPServers) {
@@ -407,29 +407,11 @@ export async function loadCliConfig(
   }
 
   if (argv.allowedMcpServerNames) {
-    const allowedNames = new Set(argv.allowedMcpServerNames.filter(Boolean));
-    if (allowedNames.size > 0) {
-      mcpServers = Object.fromEntries(
-        Object.entries(mcpServers).filter(([key, server]) => {
-          const isAllowed = allowedNames.has(key);
-          if (!isAllowed) {
-            blockedMcpServers.push({
-              name: key,
-              extensionName: server.extensionName || '',
-            });
-          }
-          return isAllowed;
-        }),
-      );
-    } else {
-      blockedMcpServers.push(
-        ...Object.entries(mcpServers).map(([key, server]) => ({
-          name: key,
-          extensionName: server.extensionName || '',
-        })),
-      );
-      mcpServers = {};
-    }
+    mcpServers = allowedMcpServers(
+      mcpServers,
+      argv.allowedMcpServerNames,
+      blockedMcpServers,
+    );
   }
 
   const sandboxConfig = await loadSandboxConfig(settings, argv);
@@ -509,6 +491,37 @@ export async function loadCliConfig(
   });
 }
 
+function allowedMcpServers(
+  mcpServers: { [x: string]: MCPServerConfig },
+  allowMCPServers: string[],
+  blockedMcpServers: Array<{ name: string; extensionName: string }>,
+) {
+  const allowedNames = new Set(allowMCPServers.filter(Boolean));
+  if (allowedNames.size > 0) {
+    mcpServers = Object.fromEntries(
+      Object.entries(mcpServers).filter(([key, server]) => {
+        const isAllowed = allowedNames.has(key);
+        if (!isAllowed) {
+          blockedMcpServers.push({
+            name: key,
+            extensionName: server.extensionName || '',
+          });
+        }
+        return isAllowed;
+      }),
+    );
+  } else {
+    blockedMcpServers.push(
+      ...Object.entries(mcpServers).map(([key, server]) => ({
+        name: key,
+        extensionName: server.extensionName || '',
+      })),
+    );
+    mcpServers = {};
+  }
+  return mcpServers;
+}
+
 function mergeMcpServers(settings: Settings, extensions: Extension[]) {
   const mcpServers = { ...(settings.mcpServers || {}) };
   for (const extension of extensions) {

From bae922a6327a8ae97ca53ac1829ff385ca025460 Mon Sep 17 00:00:00 2001
From: shishu314 <shishu_1998@yahoo.com>
Date: Thu, 7 Aug 2025 19:58:18 -0400
Subject: [PATCH 055/107] fix(cli) - Move logging into CodeAssistServer (#5781)

Co-authored-by: Shi Shu <shii@google.com>
---
 .../core/src/code_assist/converter.test.ts    | 55 +++++++++++++++
 packages/core/src/code_assist/converter.ts    |  2 +-
 packages/core/src/code_assist/server.test.ts  |  6 +-
 .../core/src/core/contentGenerator.test.ts    | 17 +++--
 packages/core/src/core/contentGenerator.ts    | 16 +++--
 packages/core/src/core/geminiChat.ts          | 31 +--------
 .../core/src/core/loggingContentGenerator.ts  | 68 +++++++++++++++++++
 .../src/core/nonInteractiveToolExecutor.ts    |  2 +-
 packages/core/src/telemetry/loggers.test.ts   |  2 +-
 .../core/src/telemetry/tool-call-decision.ts  | 32 +++++++++
 packages/core/src/telemetry/types.ts          | 30 ++------
 .../core/src/telemetry/uiTelemetry.test.ts    |  8 +--
 packages/core/src/telemetry/uiTelemetry.ts    |  8 +--
 13 files changed, 195 insertions(+), 82 deletions(-)
 create mode 100644 packages/core/src/core/loggingContentGenerator.ts
 create mode 100644 packages/core/src/telemetry/tool-call-decision.ts

diff --git a/packages/core/src/code_assist/converter.test.ts b/packages/core/src/code_assist/converter.test.ts
index 3d3a8ef3..ab040fe6 100644
--- a/packages/core/src/code_assist/converter.test.ts
+++ b/packages/core/src/code_assist/converter.test.ts
@@ -9,8 +9,10 @@ import {
   toGenerateContentRequest,
   fromGenerateContentResponse,
   CaGenerateContentResponse,
+  toContents,
 } from './converter.js';
 import {
+  ContentListUnion,
   GenerateContentParameters,
   GenerateContentResponse,
   FinishReason,
@@ -295,4 +297,57 @@ describe('converter', () => {
       );
     });
   });
+
+  describe('toContents', () => {
+    it('should handle Content', () => {
+      const content: ContentListUnion = {
+        role: 'user',
+        parts: [{ text: 'hello' }],
+      };
+      expect(toContents(content)).toEqual([
+        { role: 'user', parts: [{ text: 'hello' }] },
+      ]);
+    });
+
+    it('should handle array of Contents', () => {
+      const contents: ContentListUnion = [
+        { role: 'user', parts: [{ text: 'hello' }] },
+        { role: 'model', parts: [{ text: 'hi' }] },
+      ];
+      expect(toContents(contents)).toEqual([
+        { role: 'user', parts: [{ text: 'hello' }] },
+        { role: 'model', parts: [{ text: 'hi' }] },
+      ]);
+    });
+
+    it('should handle Part', () => {
+      const part: ContentListUnion = { text: 'a part' };
+      expect(toContents(part)).toEqual([
+        { role: 'user', parts: [{ text: 'a part' }] },
+      ]);
+    });
+
+    it('should handle array of Parts', () => {
+      const parts = [{ text: 'part 1' }, 'part 2'];
+      expect(toContents(parts)).toEqual([
+        { role: 'user', parts: [{ text: 'part 1' }] },
+        { role: 'user', parts: [{ text: 'part 2' }] },
+      ]);
+    });
+
+    it('should handle string', () => {
+      const str: ContentListUnion = 'a string';
+      expect(toContents(str)).toEqual([
+        { role: 'user', parts: [{ text: 'a string' }] },
+      ]);
+    });
+
+    it('should handle array of strings', () => {
+      const strings: ContentListUnion = ['string 1', 'string 2'];
+      expect(toContents(strings)).toEqual([
+        { role: 'user', parts: [{ text: 'string 1' }] },
+        { role: 'user', parts: [{ text: 'string 2' }] },
+      ]);
+    });
+  });
 });
diff --git a/packages/core/src/code_assist/converter.ts b/packages/core/src/code_assist/converter.ts
index ffd471da..a71c70da 100644
--- a/packages/core/src/code_assist/converter.ts
+++ b/packages/core/src/code_assist/converter.ts
@@ -157,7 +157,7 @@ function toVertexGenerateContentRequest(
   };
 }
 
-function toContents(contents: ContentListUnion): Content[] {
+export function toContents(contents: ContentListUnion): Content[] {
   if (Array.isArray(contents)) {
     // it's a Content[] or a PartsUnion[]
     return contents.map(toContent);
diff --git a/packages/core/src/code_assist/server.test.ts b/packages/core/src/code_assist/server.test.ts
index 3fc1891f..bc3978fb 100644
--- a/packages/core/src/code_assist/server.test.ts
+++ b/packages/core/src/code_assist/server.test.ts
@@ -4,7 +4,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import { describe, it, expect, vi } from 'vitest';
+import { beforeEach, describe, it, expect, vi } from 'vitest';
 import { CodeAssistServer } from './server.js';
 import { OAuth2Client } from 'google-auth-library';
 import { UserTierId } from './types.js';
@@ -12,6 +12,10 @@ import { UserTierId } from './types.js';
 vi.mock('google-auth-library');
 
 describe('CodeAssistServer', () => {
+  beforeEach(() => {
+    vi.resetAllMocks();
+  });
+
   it('should be able to be constructed', () => {
     const auth = new OAuth2Client();
     const server = new CodeAssistServer(
diff --git a/packages/core/src/core/contentGenerator.test.ts b/packages/core/src/core/contentGenerator.test.ts
index 78eee386..e89b5bc7 100644
--- a/packages/core/src/core/contentGenerator.test.ts
+++ b/packages/core/src/core/contentGenerator.test.ts
@@ -9,10 +9,12 @@ import {
   createContentGenerator,
   AuthType,
   createContentGeneratorConfig,
+  ContentGenerator,
 } from './contentGenerator.js';
 import { createCodeAssistContentGenerator } from '../code_assist/codeAssist.js';
 import { GoogleGenAI } from '@google/genai';
 import { Config } from '../config/config.js';
+import { LoggingContentGenerator } from './loggingContentGenerator.js';
 
 vi.mock('../code_assist/codeAssist.js');
 vi.mock('@google/genai');
@@ -21,7 +23,7 @@ const mockConfig = {} as unknown as Config;
 
 describe('createContentGenerator', () => {
   it('should create a CodeAssistContentGenerator', async () => {
-    const mockGenerator = {} as unknown;
+    const mockGenerator = {} as unknown as ContentGenerator;
     vi.mocked(createCodeAssistContentGenerator).mockResolvedValue(
       mockGenerator as never,
     );
@@ -33,13 +35,15 @@ describe('createContentGenerator', () => {
       mockConfig,
     );
     expect(createCodeAssistContentGenerator).toHaveBeenCalled();
-    expect(generator).toBe(mockGenerator);
+    expect(generator).toEqual(
+      new LoggingContentGenerator(mockGenerator, mockConfig),
+    );
   });
 
   it('should create a GoogleGenAI content generator', async () => {
     const mockGenerator = {
       models: {},
-    } as unknown;
+    } as unknown as GoogleGenAI;
     vi.mocked(GoogleGenAI).mockImplementation(() => mockGenerator as never);
     const generator = await createContentGenerator(
       {
@@ -58,7 +62,12 @@ describe('createContentGenerator', () => {
         },
       },
     });
-    expect(generator).toBe((mockGenerator as GoogleGenAI).models);
+    expect(generator).toEqual(
+      new LoggingContentGenerator(
+        (mockGenerator as GoogleGenAI).models,
+        mockConfig,
+      ),
+    );
   });
 });
 
diff --git a/packages/core/src/core/contentGenerator.ts b/packages/core/src/core/contentGenerator.ts
index 797bad73..ac716ac3 100644
--- a/packages/core/src/core/contentGenerator.ts
+++ b/packages/core/src/core/contentGenerator.ts
@@ -18,6 +18,7 @@ import { DEFAULT_GEMINI_MODEL } from '../config/models.js';
 import { Config } from '../config/config.js';
 import { getEffectiveModel } from './modelCheck.js';
 import { UserTierId } from '../code_assist/types.js';
+import { LoggingContentGenerator } from './loggingContentGenerator.js';
 
 /**
  * Interface abstracting the core functionalities for generating content and counting tokens.
@@ -121,11 +122,14 @@ export async function createContentGenerator(
     config.authType === AuthType.LOGIN_WITH_GOOGLE ||
     config.authType === AuthType.CLOUD_SHELL
   ) {
-    return createCodeAssistContentGenerator(
-      httpOptions,
-      config.authType,
+    return new LoggingContentGenerator(
+      await createCodeAssistContentGenerator(
+        httpOptions,
+        config.authType,
+        gcConfig,
+        sessionId,
+      ),
       gcConfig,
-      sessionId,
     );
   }
 
@@ -138,10 +142,8 @@ export async function createContentGenerator(
       vertexai: config.vertexai,
       httpOptions,
     });
-
-    return googleGenAI.models;
+    return new LoggingContentGenerator(googleGenAI.models, gcConfig);
   }
-
   throw new Error(
     `Error creating contentGenerator: Unsupported authType: ${config.authType}`,
   );
diff --git a/packages/core/src/core/geminiChat.ts b/packages/core/src/core/geminiChat.ts
index 085bc993..27b34d87 100644
--- a/packages/core/src/core/geminiChat.ts
+++ b/packages/core/src/core/geminiChat.ts
@@ -21,16 +21,8 @@ import { retryWithBackoff } from '../utils/retry.js';
 import { isFunctionResponse } from '../utils/messageInspectors.js';
 import { ContentGenerator, AuthType } from './contentGenerator.js';
 import { Config } from '../config/config.js';
-import {
-  logApiRequest,
-  logApiResponse,
-  logApiError,
-} from '../telemetry/loggers.js';
-import {
-  ApiErrorEvent,
-  ApiRequestEvent,
-  ApiResponseEvent,
-} from '../telemetry/types.js';
+import { logApiResponse, logApiError } from '../telemetry/loggers.js';
+import { ApiErrorEvent, ApiResponseEvent } from '../telemetry/types.js';
 import { DEFAULT_GEMINI_FLASH_MODEL } from '../config/models.js';
 import { hasCycleInSchema } from '../tools/tools.js';
 import { StructuredError } from './turn.js';
@@ -139,22 +131,6 @@ export class GeminiChat {
     validateHistory(history);
   }
 
-  private _getRequestTextFromContents(contents: Content[]): string {
-    return JSON.stringify(contents);
-  }
-
-  private async _logApiRequest(
-    contents: Content[],
-    model: string,
-    prompt_id: string,
-  ): Promise<void> {
-    const requestText = this._getRequestTextFromContents(contents);
-    logApiRequest(
-      this.config,
-      new ApiRequestEvent(model, prompt_id, requestText),
-    );
-  }
-
   private async _logApiResponse(
     durationMs: number,
     prompt_id: string,
@@ -273,8 +249,6 @@ export class GeminiChat {
     const userContent = createUserContent(params.message);
     const requestContents = this.getHistory(true).concat(userContent);
 
-    this._logApiRequest(requestContents, this.config.getModel(), prompt_id);
-
     const startTime = Date.now();
     let response: GenerateContentResponse;
 
@@ -386,7 +360,6 @@ export class GeminiChat {
     await this.sendPromise;
     const userContent = createUserContent(params.message);
     const requestContents = this.getHistory(true).concat(userContent);
-    this._logApiRequest(requestContents, this.config.getModel(), prompt_id);
 
     const startTime = Date.now();
 
diff --git a/packages/core/src/core/loggingContentGenerator.ts b/packages/core/src/core/loggingContentGenerator.ts
new file mode 100644
index 00000000..c9069bab
--- /dev/null
+++ b/packages/core/src/core/loggingContentGenerator.ts
@@ -0,0 +1,68 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import {
+  Content,
+  CountTokensParameters,
+  CountTokensResponse,
+  EmbedContentParameters,
+  EmbedContentResponse,
+  GenerateContentParameters,
+  GenerateContentResponse,
+} from '@google/genai';
+import { ApiRequestEvent } from '../telemetry/types.js';
+import { Config } from '../config/config.js';
+import { logApiRequest } from '../telemetry/loggers.js';
+import { ContentGenerator } from './contentGenerator.js';
+import { toContents } from '../code_assist/converter.js';
+
+/**
+ * A decorator that wraps a ContentGenerator to add logging to API calls.
+ */
+export class LoggingContentGenerator implements ContentGenerator {
+  constructor(
+    private readonly wrapped: ContentGenerator,
+    private readonly config: Config,
+  ) {}
+
+  private logApiRequest(
+    contents: Content[],
+    model: string,
+    promptId: string,
+  ): void {
+    const requestText = JSON.stringify(contents);
+    logApiRequest(
+      this.config,
+      new ApiRequestEvent(model, promptId, requestText),
+    );
+  }
+
+  async generateContent(
+    req: GenerateContentParameters,
+    userPromptId: string,
+  ): Promise<GenerateContentResponse> {
+    this.logApiRequest(toContents(req.contents), req.model, userPromptId);
+    return this.wrapped.generateContent(req, userPromptId);
+  }
+
+  async generateContentStream(
+    req: GenerateContentParameters,
+    userPromptId: string,
+  ): Promise<AsyncGenerator<GenerateContentResponse>> {
+    this.logApiRequest(toContents(req.contents), req.model, userPromptId);
+    return this.wrapped.generateContentStream(req, userPromptId);
+  }
+
+  async countTokens(req: CountTokensParameters): Promise<CountTokensResponse> {
+    return this.wrapped.countTokens(req);
+  }
+
+  async embedContent(
+    req: EmbedContentParameters,
+  ): Promise<EmbedContentResponse> {
+    return this.wrapped.embedContent(req);
+  }
+}
diff --git a/packages/core/src/core/nonInteractiveToolExecutor.ts b/packages/core/src/core/nonInteractiveToolExecutor.ts
index 43061f83..29d79152 100644
--- a/packages/core/src/core/nonInteractiveToolExecutor.ts
+++ b/packages/core/src/core/nonInteractiveToolExecutor.ts
@@ -14,7 +14,7 @@ import {
 } from '../index.js';
 import { Config } from '../config/config.js';
 import { convertToFunctionResponse } from './coreToolScheduler.js';
-import { ToolCallDecision } from '../telemetry/types.js';
+import { ToolCallDecision } from '../telemetry/tool-call-decision.js';
 
 /**
  * Executes a single tool call non-interactively.
diff --git a/packages/core/src/telemetry/loggers.test.ts b/packages/core/src/telemetry/loggers.test.ts
index 14de83a9..e1c4e65b 100644
--- a/packages/core/src/telemetry/loggers.test.ts
+++ b/packages/core/src/telemetry/loggers.test.ts
@@ -35,11 +35,11 @@ import {
   logToolCall,
   logFlashFallback,
 } from './loggers.js';
+import { ToolCallDecision } from './tool-call-decision.js';
 import {
   ApiRequestEvent,
   ApiResponseEvent,
   StartSessionEvent,
-  ToolCallDecision,
   ToolCallEvent,
   UserPromptEvent,
   FlashFallbackEvent,
diff --git a/packages/core/src/telemetry/tool-call-decision.ts b/packages/core/src/telemetry/tool-call-decision.ts
new file mode 100644
index 00000000..167df10a
--- /dev/null
+++ b/packages/core/src/telemetry/tool-call-decision.ts
@@ -0,0 +1,32 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { ToolConfirmationOutcome } from '../tools/tools.js';
+
+export enum ToolCallDecision {
+  ACCEPT = 'accept',
+  REJECT = 'reject',
+  MODIFY = 'modify',
+  AUTO_ACCEPT = 'auto_accept',
+}
+
+export function getDecisionFromOutcome(
+  outcome: ToolConfirmationOutcome,
+): ToolCallDecision {
+  switch (outcome) {
+    case ToolConfirmationOutcome.ProceedOnce:
+      return ToolCallDecision.ACCEPT;
+    case ToolConfirmationOutcome.ProceedAlways:
+    case ToolConfirmationOutcome.ProceedAlwaysServer:
+    case ToolConfirmationOutcome.ProceedAlwaysTool:
+      return ToolCallDecision.AUTO_ACCEPT;
+    case ToolConfirmationOutcome.ModifyWithEditor:
+      return ToolCallDecision.MODIFY;
+    case ToolConfirmationOutcome.Cancel:
+    default:
+      return ToolCallDecision.REJECT;
+  }
+}
diff --git a/packages/core/src/telemetry/types.ts b/packages/core/src/telemetry/types.ts
index db84e2da..766d5f47 100644
--- a/packages/core/src/telemetry/types.ts
+++ b/packages/core/src/telemetry/types.ts
@@ -7,33 +7,11 @@
 import { GenerateContentResponseUsageMetadata } from '@google/genai';
 import { Config } from '../config/config.js';
 import { CompletedToolCall } from '../core/coreToolScheduler.js';
-import { ToolConfirmationOutcome } from '../tools/tools.js';
 import { AuthType } from '../core/contentGenerator.js';
-
-export enum ToolCallDecision {
-  ACCEPT = 'accept',
-  REJECT = 'reject',
-  MODIFY = 'modify',
-  AUTO_ACCEPT = 'auto_accept',
-}
-
-export function getDecisionFromOutcome(
-  outcome: ToolConfirmationOutcome,
-): ToolCallDecision {
-  switch (outcome) {
-    case ToolConfirmationOutcome.ProceedOnce:
-      return ToolCallDecision.ACCEPT;
-    case ToolConfirmationOutcome.ProceedAlways:
-    case ToolConfirmationOutcome.ProceedAlwaysServer:
-    case ToolConfirmationOutcome.ProceedAlwaysTool:
-      return ToolCallDecision.AUTO_ACCEPT;
-    case ToolConfirmationOutcome.ModifyWithEditor:
-      return ToolCallDecision.MODIFY;
-    case ToolConfirmationOutcome.Cancel:
-    default:
-      return ToolCallDecision.REJECT;
-  }
-}
+import {
+  getDecisionFromOutcome,
+  ToolCallDecision,
+} from './tool-call-decision.js';
 
 export class StartSessionEvent {
   'event.name': 'cli_config';
diff --git a/packages/core/src/telemetry/uiTelemetry.test.ts b/packages/core/src/telemetry/uiTelemetry.test.ts
index ac9727f1..cd509a8e 100644
--- a/packages/core/src/telemetry/uiTelemetry.test.ts
+++ b/packages/core/src/telemetry/uiTelemetry.test.ts
@@ -6,12 +6,8 @@
 
 import { describe, it, expect, vi, beforeEach } from 'vitest';
 import { UiTelemetryService } from './uiTelemetry.js';
-import {
-  ApiErrorEvent,
-  ApiResponseEvent,
-  ToolCallEvent,
-  ToolCallDecision,
-} from './types.js';
+import { ToolCallDecision } from './tool-call-decision.js';
+import { ApiErrorEvent, ApiResponseEvent, ToolCallEvent } from './types.js';
 import {
   EVENT_API_ERROR,
   EVENT_API_RESPONSE,
diff --git a/packages/core/src/telemetry/uiTelemetry.ts b/packages/core/src/telemetry/uiTelemetry.ts
index fbf5b8dc..8d1b044f 100644
--- a/packages/core/src/telemetry/uiTelemetry.ts
+++ b/packages/core/src/telemetry/uiTelemetry.ts
@@ -11,12 +11,8 @@ import {
   EVENT_TOOL_CALL,
 } from './constants.js';
 
-import {
-  ApiErrorEvent,
-  ApiResponseEvent,
-  ToolCallEvent,
-  ToolCallDecision,
-} from './types.js';
+import { ToolCallDecision } from './tool-call-decision.js';
+import { ApiErrorEvent, ApiResponseEvent, ToolCallEvent } from './types.js';
 
 export type UiEvent =
   | (ApiResponseEvent & { 'event.name': typeof EVENT_API_RESPONSE })

From e8815ba43c8d87f3b4393b2f30f319d5f79cb84f Mon Sep 17 00:00:00 2001
From: Sandy Tao <sandytao520@icloud.com>
Date: Thu, 7 Aug 2025 17:21:42 -0700
Subject: [PATCH 056/107] feat(quality): Reset when seeing a new type of
 Markdown element (#5820)

---
 .../src/services/loopDetectionService.test.ts | 194 ++++++++++++++++++
 .../core/src/services/loopDetectionService.ts |  18 +-
 2 files changed, 206 insertions(+), 6 deletions(-)

diff --git a/packages/core/src/services/loopDetectionService.test.ts b/packages/core/src/services/loopDetectionService.test.ts
index 2ec32ae7..e5eeacd5 100644
--- a/packages/core/src/services/loopDetectionService.test.ts
+++ b/packages/core/src/services/loopDetectionService.test.ts
@@ -279,6 +279,200 @@ describe('LoopDetectionService', () => {
         expect(isLoop).toBe(false);
       }
 
+      expect(loggers.logLoopDetected).not.toHaveBeenCalled();
+    });
+    it('should reset tracking when a table is detected', () => {
+      service.reset('');
+      const repeatedContent = createRepetitiveContent(1, CONTENT_CHUNK_SIZE);
+
+      for (let i = 0; i < CONTENT_LOOP_THRESHOLD - 1; i++) {
+        service.addAndCheck(createContentEvent(repeatedContent));
+      }
+
+      // This should reset tracking and not trigger a loop
+      service.addAndCheck(createContentEvent('| Column 1 | Column 2 |'));
+
+      // Add more repeated content after table - should not trigger loop
+      for (let i = 0; i < CONTENT_LOOP_THRESHOLD - 1; i++) {
+        const isLoop = service.addAndCheck(createContentEvent(repeatedContent));
+        expect(isLoop).toBe(false);
+      }
+
+      expect(loggers.logLoopDetected).not.toHaveBeenCalled();
+    });
+
+    it('should reset tracking when a list item is detected', () => {
+      service.reset('');
+      const repeatedContent = createRepetitiveContent(1, CONTENT_CHUNK_SIZE);
+
+      for (let i = 0; i < CONTENT_LOOP_THRESHOLD - 1; i++) {
+        service.addAndCheck(createContentEvent(repeatedContent));
+      }
+
+      // This should reset tracking and not trigger a loop
+      service.addAndCheck(createContentEvent('* List item'));
+
+      // Add more repeated content after list - should not trigger loop
+      for (let i = 0; i < CONTENT_LOOP_THRESHOLD - 1; i++) {
+        const isLoop = service.addAndCheck(createContentEvent(repeatedContent));
+        expect(isLoop).toBe(false);
+      }
+
+      expect(loggers.logLoopDetected).not.toHaveBeenCalled();
+    });
+
+    it('should reset tracking when a heading is detected', () => {
+      service.reset('');
+      const repeatedContent = createRepetitiveContent(1, CONTENT_CHUNK_SIZE);
+
+      for (let i = 0; i < CONTENT_LOOP_THRESHOLD - 1; i++) {
+        service.addAndCheck(createContentEvent(repeatedContent));
+      }
+
+      // This should reset tracking and not trigger a loop
+      service.addAndCheck(createContentEvent('## Heading'));
+
+      // Add more repeated content after heading - should not trigger loop
+      for (let i = 0; i < CONTENT_LOOP_THRESHOLD - 1; i++) {
+        const isLoop = service.addAndCheck(createContentEvent(repeatedContent));
+        expect(isLoop).toBe(false);
+      }
+
+      expect(loggers.logLoopDetected).not.toHaveBeenCalled();
+    });
+
+    it('should reset tracking when a blockquote is detected', () => {
+      service.reset('');
+      const repeatedContent = createRepetitiveContent(1, CONTENT_CHUNK_SIZE);
+
+      for (let i = 0; i < CONTENT_LOOP_THRESHOLD - 1; i++) {
+        service.addAndCheck(createContentEvent(repeatedContent));
+      }
+
+      // This should reset tracking and not trigger a loop
+      service.addAndCheck(createContentEvent('> Quote text'));
+
+      // Add more repeated content after blockquote - should not trigger loop
+      for (let i = 0; i < CONTENT_LOOP_THRESHOLD - 1; i++) {
+        const isLoop = service.addAndCheck(createContentEvent(repeatedContent));
+        expect(isLoop).toBe(false);
+      }
+
+      expect(loggers.logLoopDetected).not.toHaveBeenCalled();
+    });
+
+    it('should reset tracking for various list item formats', () => {
+      const repeatedContent = createRepetitiveContent(1, CONTENT_CHUNK_SIZE);
+
+      // Test different list formats - make sure they start at beginning of line
+      const listFormats = [
+        '* Bullet item',
+        '- Dash item',
+        '+ Plus item',
+        '1. Numbered item',
+        '42. Another numbered item',
+      ];
+
+      listFormats.forEach((listFormat, index) => {
+        service.reset('');
+
+        // Build up to near threshold
+        for (let i = 0; i < CONTENT_LOOP_THRESHOLD - 1; i++) {
+          service.addAndCheck(createContentEvent(repeatedContent));
+        }
+
+        // Reset should occur with list item - add newline to ensure it starts at beginning
+        service.addAndCheck(createContentEvent('\n' + listFormat));
+
+        // Should not trigger loop after reset - use different content to avoid any cached state issues
+        const newRepeatedContent = createRepetitiveContent(
+          index + 100,
+          CONTENT_CHUNK_SIZE,
+        );
+        for (let i = 0; i < CONTENT_LOOP_THRESHOLD - 1; i++) {
+          const isLoop = service.addAndCheck(
+            createContentEvent(newRepeatedContent),
+          );
+          expect(isLoop).toBe(false);
+        }
+      });
+
+      expect(loggers.logLoopDetected).not.toHaveBeenCalled();
+    });
+
+    it('should reset tracking for various table formats', () => {
+      const repeatedContent = createRepetitiveContent(1, CONTENT_CHUNK_SIZE);
+
+      const tableFormats = [
+        '| Column 1 | Column 2 |',
+        '|---|---|',
+        '|++|++|',
+        '+---+---+',
+      ];
+
+      tableFormats.forEach((tableFormat, index) => {
+        service.reset('');
+
+        // Build up to near threshold
+        for (let i = 0; i < CONTENT_LOOP_THRESHOLD - 1; i++) {
+          service.addAndCheck(createContentEvent(repeatedContent));
+        }
+
+        // Reset should occur with table format - add newline to ensure it starts at beginning
+        service.addAndCheck(createContentEvent('\n' + tableFormat));
+
+        // Should not trigger loop after reset - use different content to avoid any cached state issues
+        const newRepeatedContent = createRepetitiveContent(
+          index + 200,
+          CONTENT_CHUNK_SIZE,
+        );
+        for (let i = 0; i < CONTENT_LOOP_THRESHOLD - 1; i++) {
+          const isLoop = service.addAndCheck(
+            createContentEvent(newRepeatedContent),
+          );
+          expect(isLoop).toBe(false);
+        }
+      });
+
+      expect(loggers.logLoopDetected).not.toHaveBeenCalled();
+    });
+
+    it('should reset tracking for various heading levels', () => {
+      const repeatedContent = createRepetitiveContent(1, CONTENT_CHUNK_SIZE);
+
+      const headingFormats = [
+        '# H1 Heading',
+        '## H2 Heading',
+        '### H3 Heading',
+        '#### H4 Heading',
+        '##### H5 Heading',
+        '###### H6 Heading',
+      ];
+
+      headingFormats.forEach((headingFormat, index) => {
+        service.reset('');
+
+        // Build up to near threshold
+        for (let i = 0; i < CONTENT_LOOP_THRESHOLD - 1; i++) {
+          service.addAndCheck(createContentEvent(repeatedContent));
+        }
+
+        // Reset should occur with heading - add newline to ensure it starts at beginning
+        service.addAndCheck(createContentEvent('\n' + headingFormat));
+
+        // Should not trigger loop after reset - use different content to avoid any cached state issues
+        const newRepeatedContent = createRepetitiveContent(
+          index + 300,
+          CONTENT_CHUNK_SIZE,
+        );
+        for (let i = 0; i < CONTENT_LOOP_THRESHOLD - 1; i++) {
+          const isLoop = service.addAndCheck(
+            createContentEvent(newRepeatedContent),
+          );
+          expect(isLoop).toBe(false);
+        }
+      });
+
       expect(loggers.logLoopDetected).not.toHaveBeenCalled();
     });
   });
diff --git a/packages/core/src/services/loopDetectionService.ts b/packages/core/src/services/loopDetectionService.ts
index f71b8434..a01e4ee9 100644
--- a/packages/core/src/services/loopDetectionService.ts
+++ b/packages/core/src/services/loopDetectionService.ts
@@ -161,13 +161,19 @@ export class LoopDetectionService {
    *    as repetitive code structures are common and not necessarily loops.
    */
   private checkContentLoop(content: string): boolean {
-    // Code blocks can often contain repetitive syntax that is not indicative of a loop.
-    // To avoid false positives, we detect when we are inside a code block and
-    // temporarily disable loop detection.
+    // Different content elements can often contain repetitive syntax that is not indicative of a loop.
+    // To avoid false positives, we detect when we encounter different content types and
+    // reset tracking to avoid analyzing content that spans across different element boundaries.
     const numFences = (content.match(/```/g) ?? []).length;
-    if (numFences) {
-      // Reset tracking when a code fence is detected to avoid analyzing content
-      // that spans across code block boundaries.
+    const hasTable = /(^|\n)\s*(\|.*\||[|+-]{3,})/.test(content);
+    const hasListItem =
+      /(^|\n)\s*[*-+]\s/.test(content) || /(^|\n)\s*\d+\.\s/.test(content);
+    const hasHeading = /(^|\n)#+\s/.test(content);
+    const hasBlockquote = /(^|\n)>\s/.test(content);
+
+    if (numFences || hasTable || hasListItem || hasHeading || hasBlockquote) {
+      // Reset tracking when different content elements are detected to avoid analyzing content
+      // that spans across different element boundaries.
       this.resetContentTracking();
     }
 

From e50d886ba86b4d6ad33ad4d9cff4f78802908451 Mon Sep 17 00:00:00 2001
From: Jerop Kipruto <jerop@google.com>
Date: Fri, 8 Aug 2025 10:17:19 +0900
Subject: [PATCH 057/107] docs: Improve local telemetry example (#5818)

---
 docs/telemetry.md | 12 +++++++++++-
 1 file changed, 11 insertions(+), 1 deletion(-)

diff --git a/docs/telemetry.md b/docs/telemetry.md
index c7b88ba9..16bff27b 100644
--- a/docs/telemetry.md
+++ b/docs/telemetry.md
@@ -58,7 +58,17 @@ You can export all telemetry data to a file for local inspection.
 To enable file export, use the `--telemetry-outfile` flag with a path to your desired output file. This must be run using `--telemetry-target=local`.
 
 ```bash
-gemini --telemetry --telemetry-target=local --telemetry-outfile=/path/to/telemetry.log "your prompt"
+# Set your desired output file path
+TELEMETRY_FILE=".gemini/telemetry.log"
+
+# Run Gemini CLI with local telemetry
+# NOTE: --telemetry-otlp-endpoint="" is required to override the default
+# OTLP exporter and ensure telemetry is written to the local file.
+gemini --telemetry \
+  --telemetry-target=local \
+  --telemetry-otlp-endpoint="" \
+  --telemetry-outfile="$TELEMETRY_FILE" \
+  --prompt "What is OpenTelemetry?"
 ```
 
 ## Running an OTEL Collector

From 86eaa03f8a0c52bbcab2cb8b6554918e30918f66 Mon Sep 17 00:00:00 2001
From: Gal Zahavi <38544478+galz10@users.noreply.github.com>
Date: Thu, 7 Aug 2025 18:53:39 -0700
Subject: [PATCH 058/107] feat(telemetry): Prevent memory leak in
 ClearcutLogger (#5734)

---
 package-lock.json                             |  18 ++
 package.json                                  |   3 +-
 .../clearcut-logger/clearcut-logger.test.ts   | 263 ++++++++++++++++
 .../clearcut-logger/clearcut-logger.ts        | 281 +++++++++++++-----
 4 files changed, 492 insertions(+), 73 deletions(-)
 create mode 100644 packages/core/src/telemetry/clearcut-logger/clearcut-logger.test.ts

diff --git a/package-lock.json b/package-lock.json
index 2efb7e40..150a4ebf 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -35,6 +35,7 @@
         "json": "^11.0.0",
         "lodash": "^4.17.21",
         "memfs": "^4.17.2",
+        "mnemonist": "^0.40.3",
         "mock-fs": "^5.5.0",
         "prettier": "^3.5.3",
         "react-devtools-core": "^4.28.5",
@@ -7860,6 +7861,16 @@
         "node": ">=16 || 14 >=14.17"
       }
     },
+    "node_modules/mnemonist": {
+      "version": "0.40.3",
+      "resolved": "https://registry.npmjs.org/mnemonist/-/mnemonist-0.40.3.tgz",
+      "integrity": "sha512-Vjyr90sJ23CKKH/qPAgUKicw/v6pRoamxIEDFOF8uSgFME7DqPRpHgRTejWVjkdGg5dXj0/NyxZHZ9bcjH+2uQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "obliterator": "^2.0.4"
+      }
+    },
     "node_modules/mock-fs": {
       "version": "5.5.0",
       "resolved": "https://registry.npmjs.org/mock-fs/-/mock-fs-5.5.0.tgz",
@@ -8290,6 +8301,13 @@
         "url": "https://github.com/sponsors/ljharb"
       }
     },
+    "node_modules/obliterator": {
+      "version": "2.0.5",
+      "resolved": "https://registry.npmjs.org/obliterator/-/obliterator-2.0.5.tgz",
+      "integrity": "sha512-42CPE9AhahZRsMNslczq0ctAEtqk8Eka26QofnqC346BZdHDySk3LWka23LI7ULIw11NmltpiLagIq8gBozxTw==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/on-finished": {
       "version": "2.4.1",
       "resolved": "https://registry.npmjs.org/on-finished/-/on-finished-2.4.1.tgz",
diff --git a/package.json b/package.json
index 17442eaa..d848a81b 100644
--- a/package.json
+++ b/package.json
@@ -84,6 +84,7 @@
     "react-devtools-core": "^4.28.5",
     "typescript-eslint": "^8.30.1",
     "vitest": "^3.2.4",
-    "yargs": "^17.7.2"
+    "yargs": "^17.7.2",
+    "mnemonist": "^0.40.3"
   }
 }
diff --git a/packages/core/src/telemetry/clearcut-logger/clearcut-logger.test.ts b/packages/core/src/telemetry/clearcut-logger/clearcut-logger.test.ts
new file mode 100644
index 00000000..f955eb5a
--- /dev/null
+++ b/packages/core/src/telemetry/clearcut-logger/clearcut-logger.test.ts
@@ -0,0 +1,263 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { vi, describe, it, expect, beforeEach, afterEach } from 'vitest';
+import * as https from 'https';
+import { ClientRequest, IncomingMessage } from 'http';
+import { Readable, Writable } from 'stream';
+
+import {
+  ClearcutLogger,
+  LogResponse,
+  LogEventEntry,
+} from './clearcut-logger.js';
+import { Config } from '../../config/config.js';
+import * as userAccount from '../../utils/user_account.js';
+import * as userId from '../../utils/user_id.js';
+
+// Mock dependencies
+vi.mock('https-proxy-agent');
+vi.mock('https');
+vi.mock('../../utils/user_account');
+vi.mock('../../utils/user_id');
+
+const mockHttps = vi.mocked(https);
+const mockUserAccount = vi.mocked(userAccount);
+const mockUserId = vi.mocked(userId);
+
+describe('ClearcutLogger', () => {
+  let mockConfig: Config;
+  let logger: ClearcutLogger | undefined;
+
+  // A helper to get the internal events array for testing
+  const getEvents = (l: ClearcutLogger): LogEventEntry[][] =>
+    l['events'].toArray() as LogEventEntry[][];
+
+  const getEventsSize = (l: ClearcutLogger): number => l['events'].size;
+
+  const getMaxEvents = (l: ClearcutLogger): number => l['max_events'];
+
+  const getMaxRetryEvents = (l: ClearcutLogger): number =>
+    l['max_retry_events'];
+
+  const requeueFailedEvents = (l: ClearcutLogger, events: LogEventEntry[][]) =>
+    l['requeueFailedEvents'](events);
+
+  beforeEach(() => {
+    vi.useFakeTimers();
+    vi.setSystemTime(new Date());
+
+    mockConfig = {
+      getUsageStatisticsEnabled: vi.fn().mockReturnValue(true),
+      getDebugMode: vi.fn().mockReturnValue(false),
+      getSessionId: vi.fn().mockReturnValue('test-session-id'),
+      getProxy: vi.fn().mockReturnValue(undefined),
+    } as unknown as Config;
+
+    mockUserAccount.getCachedGoogleAccount.mockReturnValue('test@google.com');
+    mockUserAccount.getLifetimeGoogleAccounts.mockReturnValue(1);
+    mockUserId.getInstallationId.mockReturnValue('test-installation-id');
+
+    logger = ClearcutLogger.getInstance(mockConfig);
+    expect(logger).toBeDefined();
+  });
+
+  afterEach(() => {
+    ClearcutLogger.clearInstance();
+    vi.useRealTimers();
+    vi.restoreAllMocks();
+  });
+
+  it('should not return an instance if usage statistics are disabled', () => {
+    ClearcutLogger.clearInstance();
+    vi.spyOn(mockConfig, 'getUsageStatisticsEnabled').mockReturnValue(false);
+    const disabledLogger = ClearcutLogger.getInstance(mockConfig);
+    expect(disabledLogger).toBeUndefined();
+  });
+
+  describe('enqueueLogEvent', () => {
+    it('should add events to the queue', () => {
+      logger!.enqueueLogEvent({ test: 'event1' });
+      expect(getEventsSize(logger!)).toBe(1);
+    });
+
+    it('should evict the oldest event when the queue is full', () => {
+      const maxEvents = getMaxEvents(logger!);
+
+      for (let i = 0; i < maxEvents; i++) {
+        logger!.enqueueLogEvent({ event_id: i });
+      }
+
+      expect(getEventsSize(logger!)).toBe(maxEvents);
+      const firstEvent = JSON.parse(
+        getEvents(logger!)[0][0].source_extension_json,
+      );
+      expect(firstEvent.event_id).toBe(0);
+
+      // This should push out the first event
+      logger!.enqueueLogEvent({ event_id: maxEvents });
+
+      expect(getEventsSize(logger!)).toBe(maxEvents);
+      const newFirstEvent = JSON.parse(
+        getEvents(logger!)[0][0].source_extension_json,
+      );
+      expect(newFirstEvent.event_id).toBe(1);
+      const lastEvent = JSON.parse(
+        getEvents(logger!)[maxEvents - 1][0].source_extension_json,
+      );
+      expect(lastEvent.event_id).toBe(maxEvents);
+    });
+  });
+
+  describe('flushToClearcut', () => {
+    let mockRequest: Writable;
+    let mockResponse: Readable & Partial<IncomingMessage>;
+
+    beforeEach(() => {
+      mockRequest = new Writable({
+        write(chunk, encoding, callback) {
+          callback();
+        },
+      });
+      vi.spyOn(mockRequest, 'on');
+      vi.spyOn(mockRequest, 'end').mockReturnThis();
+      vi.spyOn(mockRequest, 'destroy').mockReturnThis();
+
+      mockResponse = new Readable({ read() {} }) as Readable &
+        Partial<IncomingMessage>;
+
+      mockHttps.request.mockImplementation(
+        (
+          _options: string | https.RequestOptions | URL,
+          ...args: unknown[]
+        ): ClientRequest => {
+          const callback = args.find((arg) => typeof arg === 'function') as
+            | ((res: IncomingMessage) => void)
+            | undefined;
+
+          if (callback) {
+            callback(mockResponse as IncomingMessage);
+          }
+          return mockRequest as ClientRequest;
+        },
+      );
+    });
+
+    it('should clear events on successful flush', async () => {
+      mockResponse.statusCode = 200;
+      const mockResponseBody = { nextRequestWaitMs: 1000 };
+      // Encoded protobuf for {nextRequestWaitMs: 1000} which is `08 E8 07`
+      const encodedResponse = Buffer.from([8, 232, 7]);
+
+      logger!.enqueueLogEvent({ event_id: 1 });
+      const flushPromise = logger!.flushToClearcut();
+
+      mockResponse.push(encodedResponse);
+      mockResponse.push(null); // End the stream
+
+      const response: LogResponse = await flushPromise;
+
+      expect(getEventsSize(logger!)).toBe(0);
+      expect(response.nextRequestWaitMs).toBe(
+        mockResponseBody.nextRequestWaitMs,
+      );
+    });
+
+    it('should handle a network error and requeue events', async () => {
+      logger!.enqueueLogEvent({ event_id: 1 });
+      logger!.enqueueLogEvent({ event_id: 2 });
+      expect(getEventsSize(logger!)).toBe(2);
+
+      const flushPromise = logger!.flushToClearcut();
+      mockRequest.emit('error', new Error('Network error'));
+      await flushPromise;
+
+      expect(getEventsSize(logger!)).toBe(2);
+      const events = getEvents(logger!);
+      expect(JSON.parse(events[0][0].source_extension_json).event_id).toBe(1);
+    });
+
+    it('should handle an HTTP error and requeue events', async () => {
+      mockResponse.statusCode = 500;
+      mockResponse.statusMessage = 'Internal Server Error';
+
+      logger!.enqueueLogEvent({ event_id: 1 });
+      logger!.enqueueLogEvent({ event_id: 2 });
+      expect(getEventsSize(logger!)).toBe(2);
+
+      const flushPromise = logger!.flushToClearcut();
+      mockResponse.emit('end'); // End the response to trigger promise resolution
+      await flushPromise;
+
+      expect(getEventsSize(logger!)).toBe(2);
+      const events = getEvents(logger!);
+      expect(JSON.parse(events[0][0].source_extension_json).event_id).toBe(1);
+    });
+  });
+
+  describe('requeueFailedEvents logic', () => {
+    it('should limit the number of requeued events to max_retry_events', () => {
+      const maxRetryEvents = getMaxRetryEvents(logger!);
+      const eventsToLogCount = maxRetryEvents + 5;
+      const eventsToSend: LogEventEntry[][] = [];
+      for (let i = 0; i < eventsToLogCount; i++) {
+        eventsToSend.push([
+          {
+            event_time_ms: Date.now(),
+            source_extension_json: JSON.stringify({ event_id: i }),
+          },
+        ]);
+      }
+
+      requeueFailedEvents(logger!, eventsToSend);
+
+      expect(getEventsSize(logger!)).toBe(maxRetryEvents);
+      const firstRequeuedEvent = JSON.parse(
+        getEvents(logger!)[0][0].source_extension_json,
+      );
+      // The last `maxRetryEvents` are kept. The oldest of those is at index `eventsToLogCount - maxRetryEvents`.
+      expect(firstRequeuedEvent.event_id).toBe(
+        eventsToLogCount - maxRetryEvents,
+      );
+    });
+
+    it('should not requeue more events than available space in the queue', () => {
+      const maxEvents = getMaxEvents(logger!);
+      const spaceToLeave = 5;
+      const initialEventCount = maxEvents - spaceToLeave;
+      for (let i = 0; i < initialEventCount; i++) {
+        logger!.enqueueLogEvent({ event_id: `initial_${i}` });
+      }
+      expect(getEventsSize(logger!)).toBe(initialEventCount);
+
+      const failedEventsCount = 10; // More than spaceToLeave
+      const eventsToSend: LogEventEntry[][] = [];
+      for (let i = 0; i < failedEventsCount; i++) {
+        eventsToSend.push([
+          {
+            event_time_ms: Date.now(),
+            source_extension_json: JSON.stringify({ event_id: `failed_${i}` }),
+          },
+        ]);
+      }
+
+      requeueFailedEvents(logger!, eventsToSend);
+
+      // availableSpace is 5. eventsToRequeue is min(10, 5) = 5.
+      // Total size should be initialEventCount + 5 = maxEvents.
+      expect(getEventsSize(logger!)).toBe(maxEvents);
+
+      // The requeued events are the *last* 5 of the failed events.
+      // startIndex = max(0, 10 - 5) = 5.
+      // Loop unshifts events from index 9 down to 5.
+      // The first element in the deque is the one with id 'failed_5'.
+      const firstRequeuedEvent = JSON.parse(
+        getEvents(logger!)[0][0].source_extension_json,
+      );
+      expect(firstRequeuedEvent.event_id).toBe('failed_5');
+    });
+  });
+});
diff --git a/packages/core/src/telemetry/clearcut-logger/clearcut-logger.ts b/packages/core/src/telemetry/clearcut-logger/clearcut-logger.ts
index 45a657c7..bff9f28e 100644
--- a/packages/core/src/telemetry/clearcut-logger/clearcut-logger.ts
+++ b/packages/core/src/telemetry/clearcut-logger/clearcut-logger.ts
@@ -30,8 +30,8 @@ import {
   getCachedGoogleAccount,
   getLifetimeGoogleAccounts,
 } from '../../utils/user_account.js';
-import { HttpError, retryWithBackoff } from '../../utils/retry.js';
 import { getInstallationId } from '../../utils/user_id.js';
+import { FixedDeque } from 'mnemonist';
 
 const start_session_event_name = 'start_session';
 const new_prompt_event_name = 'new_prompt';
@@ -51,6 +51,25 @@ export interface LogResponse {
   nextRequestWaitMs?: number;
 }
 
+export interface LogEventEntry {
+  event_time_ms: number;
+  source_extension_json: string;
+}
+
+export type EventValue = {
+  gemini_cli_key: EventMetadataKey | string;
+  value: string;
+};
+
+export type LogEvent = {
+  console_type: string;
+  application: number;
+  event_name: string;
+  event_metadata: EventValue[][];
+  client_email?: string;
+  client_install_id?: string;
+};
+
 /**
  * Determine the surface that the user is currently using.  Surface is effectively the
  * distribution channel in which the user is using Gemini CLI.  Gemini CLI comes bundled
@@ -75,13 +94,17 @@ function determineSurface(): string {
 export class ClearcutLogger {
   private static instance: ClearcutLogger;
   private config?: Config;
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any -- Clearcut expects this format.
-  private readonly events: any = [];
+  private readonly events: FixedDeque<LogEventEntry[]>;
   private last_flush_time: number = Date.now();
   private flush_interval_ms: number = 1000 * 60; // Wait at least a minute before flushing events.
+  private readonly max_events: number = 1000; // Maximum events to keep in memory
+  private readonly max_retry_events: number = 100; // Maximum failed events to retry
+  private flushing: boolean = false; // Prevent concurrent flush operations
+  private pendingFlush: boolean = false; // Track if a flush was requested during an ongoing flush
 
   private constructor(config?: Config) {
     this.config = config;
+    this.events = new FixedDeque<LogEventEntry[]>(Array, this.max_events);
   }
 
   static getInstance(config?: Config): ClearcutLogger | undefined {
@@ -93,17 +116,41 @@ export class ClearcutLogger {
     return ClearcutLogger.instance;
   }
 
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any -- Clearcut expects this format.
-  enqueueLogEvent(event: any): void {
-    this.events.push([
-      {
-        event_time_ms: Date.now(),
-        source_extension_json: safeJsonStringify(event),
-      },
-    ]);
+  /** For testing purposes only. */
+  static clearInstance(): void {
+    // @ts-expect-error - ClearcutLogger is a singleton, but we need to clear it for tests.
+    ClearcutLogger.instance = undefined;
   }
 
-  createLogEvent(name: string, data: object[]): object {
+  enqueueLogEvent(event: object): void {
+    try {
+      // Manually handle overflow for FixedDeque, which throws when full.
+      const wasAtCapacity = this.events.size >= this.max_events;
+
+      if (wasAtCapacity) {
+        this.events.shift(); // Evict oldest element to make space.
+      }
+
+      this.events.push([
+        {
+          event_time_ms: Date.now(),
+          source_extension_json: safeJsonStringify(event),
+        },
+      ]);
+
+      if (wasAtCapacity && this.config?.getDebugMode()) {
+        console.debug(
+          `ClearcutLogger: Dropped old event to prevent memory leak (queue size: ${this.events.size})`,
+        );
+      }
+    } catch (error) {
+      if (this.config?.getDebugMode()) {
+        console.error('ClearcutLogger: Failed to enqueue log event.', error);
+      }
+    }
+  }
+
+  createLogEvent(name: string, data: EventValue[]): LogEvent {
     const email = getCachedGoogleAccount();
     const totalAccounts = getLifetimeGoogleAccounts();
     data.push({
@@ -111,12 +158,11 @@ export class ClearcutLogger {
       value: totalAccounts.toString(),
     });
 
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const logEvent: any = {
+    const logEvent: LogEvent = {
       console_type: 'GEMINI_CLI',
       application: 102,
       event_name: name,
-      event_metadata: [data] as object[],
+      event_metadata: [data],
     };
 
     // Should log either email or install ID, not both. See go/cloudmill-1p-oss-instrumentation#define-sessionable-id
@@ -140,16 +186,25 @@ export class ClearcutLogger {
   }
 
   async flushToClearcut(): Promise<LogResponse> {
+    if (this.flushing) {
+      if (this.config?.getDebugMode()) {
+        console.debug(
+          'ClearcutLogger: Flush already in progress, marking pending flush.',
+        );
+      }
+      this.pendingFlush = true;
+      return Promise.resolve({});
+    }
+    this.flushing = true;
+
     if (this.config?.getDebugMode()) {
       console.log('Flushing log events to Clearcut.');
     }
-    const eventsToSend = [...this.events];
-    if (eventsToSend.length === 0) {
-      return {};
-    }
+    const eventsToSend = this.events.toArray() as LogEventEntry[][];
+    this.events.clear();
 
-    const flushFn = () =>
-      new Promise<Buffer>((resolve, reject) => {
+    return new Promise<{ buffer: Buffer; statusCode?: number }>(
+      (resolve, reject) => {
         const request = [
           {
             log_source_name: 'CONCORD',
@@ -163,6 +218,7 @@ export class ClearcutLogger {
           path: '/log',
           method: 'POST',
           headers: { 'Content-Length': Buffer.byteLength(body) },
+          timeout: 30000, // 30-second timeout
         };
         const bufs: Buffer[] = [];
         const req = https.request(
@@ -171,49 +227,77 @@ export class ClearcutLogger {
             agent: this.getProxyAgent(),
           },
           (res) => {
-            if (
-              res.statusCode &&
-              (res.statusCode < 200 || res.statusCode >= 300)
-            ) {
-              const err: HttpError = new Error(
-                `Request failed with status ${res.statusCode}`,
-              );
-              err.status = res.statusCode;
-              res.resume();
-              return reject(err);
-            }
+            res.on('error', reject); // Handle stream errors
             res.on('data', (buf) => bufs.push(buf));
-            res.on('end', () => resolve(Buffer.concat(bufs)));
+            res.on('end', () => {
+              try {
+                const buffer = Buffer.concat(bufs);
+                // Check if we got a successful response
+                if (
+                  res.statusCode &&
+                  res.statusCode >= 200 &&
+                  res.statusCode < 300
+                ) {
+                  resolve({ buffer, statusCode: res.statusCode });
+                } else {
+                  // HTTP error - reject with status code for retry handling
+                  reject(
+                    new Error(`HTTP ${res.statusCode}: ${res.statusMessage}`),
+                  );
+                }
+              } catch (e) {
+                reject(e);
+              }
+            });
           },
         );
-        req.on('error', reject);
+        req.on('error', (e) => {
+          // Network-level error
+          reject(e);
+        });
+        req.on('timeout', () => {
+          if (!req.destroyed) {
+            req.destroy(new Error('Request timeout after 30 seconds'));
+          }
+        });
         req.end(body);
+      },
+    )
+      .then(({ buffer }) => {
+        try {
+          this.last_flush_time = Date.now();
+          return this.decodeLogResponse(buffer) || {};
+        } catch (error: unknown) {
+          console.error('Error decoding log response:', error);
+          return {};
+        }
+      })
+      .catch((error: unknown) => {
+        // Handle both network-level and HTTP-level errors
+        if (this.config?.getDebugMode()) {
+          console.error('Error flushing log events:', error);
+        }
+
+        // Re-queue failed events for retry
+        this.requeueFailedEvents(eventsToSend);
+
+        // Return empty response to maintain the Promise<LogResponse> contract
+        return {};
+      })
+      .finally(() => {
+        this.flushing = false;
+
+        // If a flush was requested while we were flushing, flush again
+        if (this.pendingFlush) {
+          this.pendingFlush = false;
+          // Fire and forget the pending flush
+          this.flushToClearcut().catch((error) => {
+            if (this.config?.getDebugMode()) {
+              console.debug('Error in pending flush to Clearcut:', error);
+            }
+          });
+        }
       });
-
-    try {
-      const responseBuffer = await retryWithBackoff(flushFn, {
-        maxAttempts: 3,
-        initialDelayMs: 200,
-        shouldRetry: (err: unknown) => {
-          if (!(err instanceof Error)) return false;
-          const status = (err as HttpError).status as number | undefined;
-          // If status is not available, it's likely a network error
-          if (status === undefined) return true;
-
-          // Retry on 429 (Too many Requests) and 5xx server errors.
-          return status === 429 || (status >= 500 && status < 600);
-        },
-      });
-
-      this.events.splice(0, eventsToSend.length);
-      this.last_flush_time = Date.now();
-      return this.decodeLogResponse(responseBuffer) || {};
-    } catch (error) {
-      if (this.config?.getDebugMode()) {
-        console.error('Clearcut flush failed after multiple retries.', error);
-      }
-      return {};
-    }
   }
 
   // Visible for testing. Decodes protobuf-encoded response from Clearcut server.
@@ -258,7 +342,7 @@ export class ClearcutLogger {
   logStartSessionEvent(event: StartSessionEvent): void {
     const surface = determineSurface();
 
-    const data = [
+    const data: EventValue[] = [
       {
         gemini_cli_key: EventMetadataKey.GEMINI_CLI_START_SESSION_MODEL,
         value: event.model,
@@ -337,7 +421,7 @@ export class ClearcutLogger {
   }
 
   logNewPromptEvent(event: UserPromptEvent): void {
-    const data = [
+    const data: EventValue[] = [
       {
         gemini_cli_key: EventMetadataKey.GEMINI_CLI_USER_PROMPT_LENGTH,
         value: JSON.stringify(event.prompt_length),
@@ -361,7 +445,7 @@ export class ClearcutLogger {
   }
 
   logToolCallEvent(event: ToolCallEvent): void {
-    const data = [
+    const data: EventValue[] = [
       {
         gemini_cli_key: EventMetadataKey.GEMINI_CLI_TOOL_CALL_NAME,
         value: JSON.stringify(event.function_name),
@@ -398,7 +482,7 @@ export class ClearcutLogger {
   }
 
   logApiRequestEvent(event: ApiRequestEvent): void {
-    const data = [
+    const data: EventValue[] = [
       {
         gemini_cli_key: EventMetadataKey.GEMINI_CLI_API_REQUEST_MODEL,
         value: JSON.stringify(event.model),
@@ -414,7 +498,7 @@ export class ClearcutLogger {
   }
 
   logApiResponseEvent(event: ApiResponseEvent): void {
-    const data = [
+    const data: EventValue[] = [
       {
         gemini_cli_key: EventMetadataKey.GEMINI_CLI_API_RESPONSE_MODEL,
         value: JSON.stringify(event.model),
@@ -471,7 +555,7 @@ export class ClearcutLogger {
   }
 
   logApiErrorEvent(event: ApiErrorEvent): void {
-    const data = [
+    const data: EventValue[] = [
       {
         gemini_cli_key: EventMetadataKey.GEMINI_CLI_API_ERROR_MODEL,
         value: JSON.stringify(event.model),
@@ -503,7 +587,7 @@ export class ClearcutLogger {
   }
 
   logFlashFallbackEvent(event: FlashFallbackEvent): void {
-    const data = [
+    const data: EventValue[] = [
       {
         gemini_cli_key: EventMetadataKey.GEMINI_CLI_AUTH_TYPE,
         value: JSON.stringify(event.auth_type),
@@ -521,7 +605,7 @@ export class ClearcutLogger {
   }
 
   logLoopDetectedEvent(event: LoopDetectedEvent): void {
-    const data = [
+    const data: EventValue[] = [
       {
         gemini_cli_key: EventMetadataKey.GEMINI_CLI_PROMPT_ID,
         value: JSON.stringify(event.prompt_id),
@@ -537,7 +621,7 @@ export class ClearcutLogger {
   }
 
   logNextSpeakerCheck(event: NextSpeakerCheckEvent): void {
-    const data = [
+    const data: EventValue[] = [
       {
         gemini_cli_key: EventMetadataKey.GEMINI_CLI_PROMPT_ID,
         value: JSON.stringify(event.prompt_id),
@@ -563,7 +647,7 @@ export class ClearcutLogger {
   }
 
   logSlashCommandEvent(event: SlashCommandEvent): void {
-    const data = [
+    const data: EventValue[] = [
       {
         gemini_cli_key: EventMetadataKey.GEMINI_CLI_SLASH_COMMAND_NAME,
         value: JSON.stringify(event.command),
@@ -582,7 +666,7 @@ export class ClearcutLogger {
   }
 
   logMalformedJsonResponseEvent(event: MalformedJsonResponseEvent): void {
-    const data = [
+    const data: EventValue[] = [
       {
         gemini_cli_key:
           EventMetadataKey.GEMINI_CLI_MALFORMED_JSON_RESPONSE_MODEL,
@@ -597,7 +681,7 @@ export class ClearcutLogger {
   }
 
   logIdeConnectionEvent(event: IdeConnectionEvent): void {
-    const data = [
+    const data: EventValue[] = [
       {
         gemini_cli_key: EventMetadataKey.GEMINI_CLI_IDE_CONNECTION_TYPE,
         value: JSON.stringify(event.connection_type),
@@ -609,7 +693,7 @@ export class ClearcutLogger {
   }
 
   logEndSessionEvent(event: EndSessionEvent): void {
-    const data = [
+    const data: EventValue[] = [
       {
         gemini_cli_key: EventMetadataKey.GEMINI_CLI_SESSION_ID,
         value: event?.session_id?.toString() ?? '',
@@ -639,4 +723,57 @@ export class ClearcutLogger {
     const event = new EndSessionEvent(this.config);
     this.logEndSessionEvent(event);
   }
+
+  private requeueFailedEvents(eventsToSend: LogEventEntry[][]): void {
+    // Add the events back to the front of the queue to be retried, but limit retry queue size
+    const eventsToRetry = eventsToSend.slice(-this.max_retry_events); // Keep only the most recent events
+
+    // Log a warning if we're dropping events
+    if (
+      eventsToSend.length > this.max_retry_events &&
+      this.config?.getDebugMode()
+    ) {
+      console.warn(
+        `ClearcutLogger: Dropping ${
+          eventsToSend.length - this.max_retry_events
+        } events due to retry queue limit. Total events: ${
+          eventsToSend.length
+        }, keeping: ${this.max_retry_events}`,
+      );
+    }
+
+    // Determine how many events can be re-queued
+    const availableSpace = this.max_events - this.events.size;
+    const numEventsToRequeue = Math.min(eventsToRetry.length, availableSpace);
+
+    if (numEventsToRequeue === 0) {
+      if (this.config?.getDebugMode()) {
+        console.debug(
+          `ClearcutLogger: No events re-queued (queue size: ${this.events.size})`,
+        );
+      }
+      return;
+    }
+
+    // Get the most recent events to re-queue
+    const eventsToRequeue = eventsToRetry.slice(
+      eventsToRetry.length - numEventsToRequeue,
+    );
+
+    // Prepend events to the front of the deque to be retried first.
+    // We iterate backwards to maintain the original order of the failed events.
+    for (let i = eventsToRequeue.length - 1; i >= 0; i--) {
+      this.events.unshift(eventsToRequeue[i]);
+    }
+    // Clear any potential overflow
+    while (this.events.size > this.max_events) {
+      this.events.pop();
+    }
+
+    if (this.config?.getDebugMode()) {
+      console.debug(
+        `ClearcutLogger: Re-queued ${numEventsToRequeue} events for retry (queue size: ${this.events.size})`,
+      );
+    }
+  }
 }

From 5ab184fcaf40d4e7dec9ba6a0526cac39b602ee2 Mon Sep 17 00:00:00 2001
From: agarwalravikant <agarwalravikant@gmail.com>
Date: Fri, 8 Aug 2025 10:08:07 +0530
Subject: [PATCH 059/107] Fix for git issue 5657 to add lines of code
 added/removed telemetry (#5823)

Co-authored-by: Ravikant Agarwal <ravikantag@google.com>
---
 docs/telemetry.md                             |   7 +-
 .../src/core/nonInteractiveToolExecutor.ts    |  20 +++
 .../clearcut-logger/clearcut-logger.ts        |  18 +++
 .../clearcut-logger/event-metadata-key.ts     |  12 ++
 packages/core/src/telemetry/metrics.test.ts   |  82 +++++++++++
 packages/core/src/telemetry/metrics.ts        |   8 ++
 packages/core/src/telemetry/types.ts          |  20 +++
 packages/core/src/tools/diffOptions.test.ts   | 129 ++++++++++++++++++
 packages/core/src/tools/diffOptions.ts        |  53 +++++++
 packages/core/src/tools/edit.ts               |  32 ++++-
 packages/core/src/tools/tools.ts              |   8 ++
 packages/core/src/tools/write-file.ts         |  33 ++++-
 12 files changed, 408 insertions(+), 14 deletions(-)
 create mode 100644 packages/core/src/tools/diffOptions.test.ts

diff --git a/docs/telemetry.md b/docs/telemetry.md
index 16bff27b..68c3aed2 100644
--- a/docs/telemetry.md
+++ b/docs/telemetry.md
@@ -183,9 +183,10 @@ Logs are timestamped records of specific events. The following events are logged
     - `function_args`
     - `duration_ms`
     - `success` (boolean)
-    - `decision` (string: "accept", "reject", or "modify", if applicable)
+    - `decision` (string: "accept", "reject", "auto_accept", or "modify", if applicable)
     - `error` (if applicable)
     - `error_type` (if applicable)
+    - `metadata` (if applicable, dictionary of string -> any)
 
 - `gemini_cli.api_request`: This event occurs when making a request to Gemini API.
   - **Attributes**:
@@ -262,3 +263,7 @@ Metrics are numerical measurements of behavior over time. The following metrics
     - `lines` (Int, if applicable): Number of lines in the file.
     - `mimetype` (string, if applicable): Mimetype of the file.
     - `extension` (string, if applicable): File extension of the file.
+    - `ai_added_lines` (Int, if applicable): Number of lines added/changed by AI.
+    - `ai_removed_lines` (Int, if applicable): Number of lines removed/changed by AI.
+    - `user_added_lines` (Int, if applicable): Number of lines added/changed by user in AI proposed changes.
+    - `user_removed_lines` (Int, if applicable): Number of lines removed/changed by user in AI proposed changes.
diff --git a/packages/core/src/core/nonInteractiveToolExecutor.ts b/packages/core/src/core/nonInteractiveToolExecutor.ts
index 29d79152..ab38d830 100644
--- a/packages/core/src/core/nonInteractiveToolExecutor.ts
+++ b/packages/core/src/core/nonInteractiveToolExecutor.ts
@@ -5,6 +5,7 @@
  */
 
 import {
+  FileDiff,
   logToolCall,
   ToolCallRequestInfo,
   ToolCallResponseInfo,
@@ -75,6 +76,24 @@ export async function executeToolCall(
 
     const tool_display = toolResult.returnDisplay;
 
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    let metadata: { [key: string]: any } = {};
+    if (
+      toolResult.error === undefined &&
+      typeof tool_display === 'object' &&
+      tool_display !== null &&
+      'diffStat' in tool_display
+    ) {
+      const diffStat = (tool_display as FileDiff).diffStat;
+      if (diffStat) {
+        metadata = {
+          ai_added_lines: diffStat.ai_added_lines,
+          ai_removed_lines: diffStat.ai_removed_lines,
+          user_added_lines: diffStat.user_added_lines,
+          user_removed_lines: diffStat.user_removed_lines,
+        };
+      }
+    }
     const durationMs = Date.now() - startTime;
     logToolCall(config, {
       'event.name': 'tool_call',
@@ -88,6 +107,7 @@ export async function executeToolCall(
       error_type:
         toolResult.error === undefined ? undefined : toolResult.error.type,
       prompt_id: toolCallRequest.prompt_id,
+      metadata,
       decision: ToolCallDecision.AUTO_ACCEPT,
     });
 
diff --git a/packages/core/src/telemetry/clearcut-logger/clearcut-logger.ts b/packages/core/src/telemetry/clearcut-logger/clearcut-logger.ts
index bff9f28e..09ae6741 100644
--- a/packages/core/src/telemetry/clearcut-logger/clearcut-logger.ts
+++ b/packages/core/src/telemetry/clearcut-logger/clearcut-logger.ts
@@ -476,6 +476,24 @@ export class ClearcutLogger {
       },
     ];
 
+    if (event.metadata) {
+      const metadataMapping: { [key: string]: EventMetadataKey } = {
+        ai_added_lines: EventMetadataKey.GEMINI_CLI_AI_ADDED_LINES,
+        ai_removed_lines: EventMetadataKey.GEMINI_CLI_AI_REMOVED_LINES,
+        user_added_lines: EventMetadataKey.GEMINI_CLI_USER_ADDED_LINES,
+        user_removed_lines: EventMetadataKey.GEMINI_CLI_USER_REMOVED_LINES,
+      };
+
+      for (const [key, gemini_cli_key] of Object.entries(metadataMapping)) {
+        if (event.metadata[key] !== undefined) {
+          data.push({
+            gemini_cli_key,
+            value: JSON.stringify(event.metadata[key]),
+          });
+        }
+      }
+    }
+
     const logEvent = this.createLogEvent(tool_call_event_name, data);
     this.enqueueLogEvent(logEvent);
     this.flushIfNeeded();
diff --git a/packages/core/src/telemetry/clearcut-logger/event-metadata-key.ts b/packages/core/src/telemetry/clearcut-logger/event-metadata-key.ts
index 54f570f1..81f41603 100644
--- a/packages/core/src/telemetry/clearcut-logger/event-metadata-key.ts
+++ b/packages/core/src/telemetry/clearcut-logger/event-metadata-key.ts
@@ -197,6 +197,18 @@ export enum EventMetadataKey {
 
   // Logs the type of the IDE connection.
   GEMINI_CLI_IDE_CONNECTION_TYPE = 46,
+
+  // Logs AI added lines in edit/write tool response.
+  GEMINI_CLI_AI_ADDED_LINES = 47,
+
+  // Logs AI removed lines in edit/write tool response.
+  GEMINI_CLI_AI_REMOVED_LINES = 48,
+
+  // Logs user added lines in edit/write tool response.
+  GEMINI_CLI_USER_ADDED_LINES = 49,
+
+  // Logs user removed lines in edit/write tool response.
+  GEMINI_CLI_USER_REMOVED_LINES = 50,
 }
 
 export function getEventMetadataKey(
diff --git a/packages/core/src/telemetry/metrics.test.ts b/packages/core/src/telemetry/metrics.test.ts
index 4fcdd9e1..7b430884 100644
--- a/packages/core/src/telemetry/metrics.test.ts
+++ b/packages/core/src/telemetry/metrics.test.ts
@@ -221,5 +221,87 @@ describe('Telemetry Metrics', () => {
         mimetype: 'application/javascript',
       });
     });
+
+    it('should include diffStat when provided', () => {
+      initializeMetricsModule(mockConfig);
+      mockCounterAddFn.mockClear();
+
+      const diffStat = {
+        ai_added_lines: 5,
+        ai_removed_lines: 2,
+        user_added_lines: 3,
+        user_removed_lines: 1,
+      };
+
+      recordFileOperationMetricModule(
+        mockConfig,
+        FileOperation.UPDATE,
+        undefined,
+        undefined,
+        undefined,
+        diffStat,
+      );
+
+      expect(mockCounterAddFn).toHaveBeenCalledWith(1, {
+        'session.id': 'test-session-id',
+        operation: FileOperation.UPDATE,
+        ai_added_lines: 5,
+        ai_removed_lines: 2,
+        user_added_lines: 3,
+        user_removed_lines: 1,
+      });
+    });
+
+    it('should not include diffStat attributes when diffStat is not provided', () => {
+      initializeMetricsModule(mockConfig);
+      mockCounterAddFn.mockClear();
+
+      recordFileOperationMetricModule(
+        mockConfig,
+        FileOperation.UPDATE,
+        10,
+        'text/plain',
+        'txt',
+        undefined,
+      );
+
+      expect(mockCounterAddFn).toHaveBeenCalledWith(1, {
+        'session.id': 'test-session-id',
+        operation: FileOperation.UPDATE,
+        lines: 10,
+        mimetype: 'text/plain',
+        extension: 'txt',
+      });
+    });
+
+    it('should handle diffStat with all zero values', () => {
+      initializeMetricsModule(mockConfig);
+      mockCounterAddFn.mockClear();
+
+      const diffStat = {
+        ai_added_lines: 0,
+        ai_removed_lines: 0,
+        user_added_lines: 0,
+        user_removed_lines: 0,
+      };
+
+      recordFileOperationMetricModule(
+        mockConfig,
+        FileOperation.UPDATE,
+        undefined,
+        undefined,
+        undefined,
+        diffStat,
+      );
+
+      expect(mockCounterAddFn).toHaveBeenCalledWith(1, {
+        'session.id': 'test-session-id',
+        operation: FileOperation.UPDATE,
+        ai_added_lines: 0,
+        ai_removed_lines: 0,
+        user_added_lines: 0,
+        user_removed_lines: 0,
+      });
+    });
   });
 });
diff --git a/packages/core/src/telemetry/metrics.ts b/packages/core/src/telemetry/metrics.ts
index 103f7f71..1e4509da 100644
--- a/packages/core/src/telemetry/metrics.ts
+++ b/packages/core/src/telemetry/metrics.ts
@@ -23,6 +23,7 @@ import {
   METRIC_FILE_OPERATION_COUNT,
 } from './constants.js';
 import { Config } from '../config/config.js';
+import { DiffStat } from '../tools/tools.js';
 
 export enum FileOperation {
   CREATE = 'create',
@@ -189,6 +190,7 @@ export function recordFileOperationMetric(
   lines?: number,
   mimetype?: string,
   extension?: string,
+  diffStat?: DiffStat,
 ): void {
   if (!fileOperationCounter || !isMetricsInitialized) return;
   const attributes: Attributes = {
@@ -198,5 +200,11 @@ export function recordFileOperationMetric(
   if (lines !== undefined) attributes.lines = lines;
   if (mimetype !== undefined) attributes.mimetype = mimetype;
   if (extension !== undefined) attributes.extension = extension;
+  if (diffStat !== undefined) {
+    attributes.ai_added_lines = diffStat.ai_added_lines;
+    attributes.ai_removed_lines = diffStat.ai_removed_lines;
+    attributes.user_added_lines = diffStat.user_added_lines;
+    attributes.user_removed_lines = diffStat.user_removed_lines;
+  }
   fileOperationCounter.add(1, attributes);
 }
diff --git a/packages/core/src/telemetry/types.ts b/packages/core/src/telemetry/types.ts
index 766d5f47..edcd8b1b 100644
--- a/packages/core/src/telemetry/types.ts
+++ b/packages/core/src/telemetry/types.ts
@@ -7,6 +7,7 @@
 import { GenerateContentResponseUsageMetadata } from '@google/genai';
 import { Config } from '../config/config.js';
 import { CompletedToolCall } from '../core/coreToolScheduler.js';
+import { FileDiff } from '../tools/tools.js';
 import { AuthType } from '../core/contentGenerator.js';
 import {
   getDecisionFromOutcome,
@@ -105,6 +106,8 @@ export class ToolCallEvent {
   error?: string;
   error_type?: string;
   prompt_id: string;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  metadata?: { [key: string]: any };
 
   constructor(call: CompletedToolCall) {
     this['event.name'] = 'tool_call';
@@ -119,6 +122,23 @@ export class ToolCallEvent {
     this.error = call.response.error?.message;
     this.error_type = call.response.errorType;
     this.prompt_id = call.request.prompt_id;
+
+    if (
+      call.status === 'success' &&
+      typeof call.response.resultDisplay === 'object' &&
+      call.response.resultDisplay !== null &&
+      'diffStat' in call.response.resultDisplay
+    ) {
+      const diffStat = (call.response.resultDisplay as FileDiff).diffStat;
+      if (diffStat) {
+        this.metadata = {
+          ai_added_lines: diffStat.ai_added_lines,
+          ai_removed_lines: diffStat.ai_removed_lines,
+          user_added_lines: diffStat.user_added_lines,
+          user_removed_lines: diffStat.user_removed_lines,
+        };
+      }
+    }
   }
 }
 
diff --git a/packages/core/src/tools/diffOptions.test.ts b/packages/core/src/tools/diffOptions.test.ts
new file mode 100644
index 00000000..95c3beb4
--- /dev/null
+++ b/packages/core/src/tools/diffOptions.test.ts
@@ -0,0 +1,129 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { describe, expect, it } from 'vitest';
+import { getDiffStat } from './diffOptions.js';
+
+describe('getDiffStat', () => {
+  const fileName = 'test.txt';
+
+  it('should return 0 for all stats when there are no changes', () => {
+    const oldStr = 'line1\nline2\n';
+    const aiStr = 'line1\nline2\n';
+    const userStr = 'line1\nline2\n';
+    const diffStat = getDiffStat(fileName, oldStr, aiStr, userStr);
+    expect(diffStat).toEqual({
+      ai_added_lines: 0,
+      ai_removed_lines: 0,
+      user_added_lines: 0,
+      user_removed_lines: 0,
+    });
+  });
+
+  it('should correctly report AI additions', () => {
+    const oldStr = 'line1\nline2\n';
+    const aiStr = 'line1\nline2\nline3\n';
+    const userStr = 'line1\nline2\nline3\n';
+    const diffStat = getDiffStat(fileName, oldStr, aiStr, userStr);
+    expect(diffStat).toEqual({
+      ai_added_lines: 1,
+      ai_removed_lines: 0,
+      user_added_lines: 0,
+      user_removed_lines: 0,
+    });
+  });
+
+  it('should correctly report AI removals', () => {
+    const oldStr = 'line1\nline2\nline3\n';
+    const aiStr = 'line1\nline3\n';
+    const userStr = 'line1\nline3\n';
+    const diffStat = getDiffStat(fileName, oldStr, aiStr, userStr);
+    expect(diffStat).toEqual({
+      ai_added_lines: 0,
+      ai_removed_lines: 1,
+      user_added_lines: 0,
+      user_removed_lines: 0,
+    });
+  });
+
+  it('should correctly report AI modifications', () => {
+    const oldStr = 'line1\nline2\nline3\n';
+    const aiStr = 'line1\nline_two\nline3\n';
+    const userStr = 'line1\nline_two\nline3\n';
+    const diffStat = getDiffStat(fileName, oldStr, aiStr, userStr);
+    expect(diffStat).toEqual({
+      ai_added_lines: 1,
+      ai_removed_lines: 1,
+      user_added_lines: 0,
+      user_removed_lines: 0,
+    });
+  });
+
+  it('should correctly report user additions', () => {
+    const oldStr = 'line1\nline2\n';
+    const aiStr = 'line1\nline2\nline3\n';
+    const userStr = 'line1\nline2\nline3\nline4\n';
+    const diffStat = getDiffStat(fileName, oldStr, aiStr, userStr);
+    expect(diffStat).toEqual({
+      ai_added_lines: 1,
+      ai_removed_lines: 0,
+      user_added_lines: 1,
+      user_removed_lines: 0,
+    });
+  });
+
+  it('should correctly report user removals', () => {
+    const oldStr = 'line1\nline2\n';
+    const aiStr = 'line1\nline2\nline3\n';
+    const userStr = 'line1\nline2\n';
+    const diffStat = getDiffStat(fileName, oldStr, aiStr, userStr);
+    expect(diffStat).toEqual({
+      ai_added_lines: 1,
+      ai_removed_lines: 0,
+      user_added_lines: 0,
+      user_removed_lines: 1,
+    });
+  });
+
+  it('should correctly report user modifications', () => {
+    const oldStr = 'line1\nline2\n';
+    const aiStr = 'line1\nline2\nline3\n';
+    const userStr = 'line1\nline2\nline_three\n';
+    const diffStat = getDiffStat(fileName, oldStr, aiStr, userStr);
+    expect(diffStat).toEqual({
+      ai_added_lines: 1,
+      ai_removed_lines: 0,
+      user_added_lines: 1,
+      user_removed_lines: 1,
+    });
+  });
+
+  it('should handle complex changes from both AI and user', () => {
+    const oldStr = 'line1\nline2\nline3\nline4\n';
+    const aiStr = 'line_one\nline2\nline_three\nline4\n';
+    const userStr = 'line_one\nline_two\nline_three\nline4\nline5\n';
+    const diffStat = getDiffStat(fileName, oldStr, aiStr, userStr);
+    expect(diffStat).toEqual({
+      ai_added_lines: 2,
+      ai_removed_lines: 2,
+      user_added_lines: 2,
+      user_removed_lines: 1,
+    });
+  });
+
+  it('should report a single line modification as one addition and one removal', () => {
+    const oldStr = 'hello world';
+    const aiStr = 'hello universe';
+    const userStr = 'hello universe';
+    const diffStat = getDiffStat(fileName, oldStr, aiStr, userStr);
+    expect(diffStat).toEqual({
+      ai_added_lines: 1,
+      ai_removed_lines: 1,
+      user_added_lines: 0,
+      user_removed_lines: 0,
+    });
+  });
+});
diff --git a/packages/core/src/tools/diffOptions.ts b/packages/core/src/tools/diffOptions.ts
index 598b46f1..50574226 100644
--- a/packages/core/src/tools/diffOptions.ts
+++ b/packages/core/src/tools/diffOptions.ts
@@ -5,8 +5,61 @@
  */
 
 import * as Diff from 'diff';
+import { DiffStat } from './tools.js';
 
 export const DEFAULT_DIFF_OPTIONS: Diff.PatchOptions = {
   context: 3,
   ignoreWhitespace: true,
 };
+
+export function getDiffStat(
+  fileName: string,
+  oldStr: string,
+  aiStr: string,
+  userStr: string,
+): DiffStat {
+  const countLines = (patch: Diff.ParsedDiff) => {
+    let added = 0;
+    let removed = 0;
+    patch.hunks.forEach((hunk: Diff.Hunk) => {
+      hunk.lines.forEach((line: string) => {
+        if (line.startsWith('+')) {
+          added++;
+        } else if (line.startsWith('-')) {
+          removed++;
+        }
+      });
+    });
+    return { added, removed };
+  };
+
+  const patch = Diff.structuredPatch(
+    fileName,
+    fileName,
+    oldStr,
+    aiStr,
+    'Current',
+    'Proposed',
+    DEFAULT_DIFF_OPTIONS,
+  );
+  const { added: aiAddedLines, removed: aiRemovedLines } = countLines(patch);
+
+  const userPatch = Diff.structuredPatch(
+    fileName,
+    fileName,
+    aiStr,
+    userStr,
+    'Proposed',
+    'User',
+    DEFAULT_DIFF_OPTIONS,
+  );
+  const { added: userAddedLines, removed: userRemovedLines } =
+    countLines(userPatch);
+
+  return {
+    ai_added_lines: aiAddedLines,
+    ai_removed_lines: aiRemovedLines,
+    user_added_lines: userAddedLines,
+    user_removed_lines: userRemovedLines,
+  };
+}
diff --git a/packages/core/src/tools/edit.ts b/packages/core/src/tools/edit.ts
index f1d0498a..33323203 100644
--- a/packages/core/src/tools/edit.ts
+++ b/packages/core/src/tools/edit.ts
@@ -25,7 +25,7 @@ import { makeRelative, shortenPath } from '../utils/paths.js';
 import { isNodeError } from '../utils/errors.js';
 import { Config, ApprovalMode } from '../config/config.js';
 import { ensureCorrectEdit } from '../utils/editCorrector.js';
-import { DEFAULT_DIFF_OPTIONS } from './diffOptions.js';
+import { DEFAULT_DIFF_OPTIONS, getDiffStat } from './diffOptions.js';
 import { ReadFileTool } from './read-file.js';
 import { ModifiableDeclarativeTool, ModifyContext } from './modifiable-tool.js';
 import { IDEConnectionStatus } from '../ide/ide-client.js';
@@ -79,6 +79,11 @@ export interface EditToolParams {
    * Whether the edit was modified manually by the user.
    */
   modified_by_user?: boolean;
+
+  /**
+   * Initially proposed string.
+   */
+  ai_proposed_string?: string;
 }
 
 interface CalculatedEdit {
@@ -353,11 +358,20 @@ class EditToolInvocation implements ToolInvocation<EditToolParams, ToolResult> {
           'Proposed',
           DEFAULT_DIFF_OPTIONS,
         );
+        const originallyProposedContent =
+          this.params.ai_proposed_string || this.params.new_string;
+        const diffStat = getDiffStat(
+          fileName,
+          editData.currentContent ?? '',
+          originallyProposedContent,
+          this.params.new_string,
+        );
         displayResult = {
           fileDiff,
           fileName,
           originalContent: editData.currentContent,
           newContent: editData.newContent,
+          diffStat,
         };
       }
 
@@ -513,12 +527,16 @@ Expectation for required parameters:
         oldContent: string,
         modifiedProposedContent: string,
         originalParams: EditToolParams,
-      ): EditToolParams => ({
-        ...originalParams,
-        old_string: oldContent,
-        new_string: modifiedProposedContent,
-        modified_by_user: true,
-      }),
+      ): EditToolParams => {
+        const content = originalParams.new_string;
+        return {
+          ...originalParams,
+          ai_proposed_string: content,
+          old_string: oldContent,
+          new_string: modifiedProposedContent,
+          modified_by_user: true,
+        };
+      },
     };
   }
 }
diff --git a/packages/core/src/tools/tools.ts b/packages/core/src/tools/tools.ts
index ceacd6ca..8e064973 100644
--- a/packages/core/src/tools/tools.ts
+++ b/packages/core/src/tools/tools.ts
@@ -498,6 +498,14 @@ export interface FileDiff {
   fileName: string;
   originalContent: string | null;
   newContent: string;
+  diffStat?: DiffStat;
+}
+
+export interface DiffStat {
+  ai_removed_lines: number;
+  ai_added_lines: number;
+  user_added_lines: number;
+  user_removed_lines: number;
 }
 
 export interface ToolEditConfirmationDetails {
diff --git a/packages/core/src/tools/write-file.ts b/packages/core/src/tools/write-file.ts
index 9e7e3813..4a9f8d35 100644
--- a/packages/core/src/tools/write-file.ts
+++ b/packages/core/src/tools/write-file.ts
@@ -25,7 +25,7 @@ import {
   ensureCorrectEdit,
   ensureCorrectFileContent,
 } from '../utils/editCorrector.js';
-import { DEFAULT_DIFF_OPTIONS } from './diffOptions.js';
+import { DEFAULT_DIFF_OPTIONS, getDiffStat } from './diffOptions.js';
 import { ModifiableDeclarativeTool, ModifyContext } from './modifiable-tool.js';
 import { getSpecificMimeType } from '../utils/fileUtils.js';
 import {
@@ -52,6 +52,11 @@ export interface WriteFileToolParams {
    * Whether the proposed content was modified by the user.
    */
   modified_by_user?: boolean;
+
+  /**
+   * Initially proposed content.
+   */
+  ai_proposed_content?: string;
 }
 
 interface GetCorrectedFileContentResult {
@@ -283,6 +288,15 @@ export class WriteFileTool
         DEFAULT_DIFF_OPTIONS,
       );
 
+      const originallyProposedContent =
+        params.ai_proposed_content || params.content;
+      const diffStat = getDiffStat(
+        fileName,
+        currentContentForDiff,
+        originallyProposedContent,
+        params.content,
+      );
+
       const llmSuccessMessageParts = [
         isNewFile
           ? `Successfully created and wrote to new file: ${params.file_path}.`
@@ -299,6 +313,7 @@ export class WriteFileTool
         fileName,
         originalContent: correctedContentResult.originalContent,
         newContent: correctedContentResult.correctedContent,
+        diffStat,
       };
 
       const lines = fileContent.split('\n').length;
@@ -311,6 +326,7 @@ export class WriteFileTool
           lines,
           mimetype,
           extension,
+          diffStat,
         );
       } else {
         recordFileOperationMetric(
@@ -319,6 +335,7 @@ export class WriteFileTool
           lines,
           mimetype,
           extension,
+          diffStat,
         );
       }
 
@@ -418,11 +435,15 @@ export class WriteFileTool
         _oldContent: string,
         modifiedProposedContent: string,
         originalParams: WriteFileToolParams,
-      ) => ({
-        ...originalParams,
-        content: modifiedProposedContent,
-        modified_by_user: true,
-      }),
+      ) => {
+        const content = originalParams.content;
+        return {
+          ...originalParams,
+          ai_proposed_content: content,
+          content: modifiedProposedContent,
+          modified_by_user: true,
+        };
+      },
     };
   }
 }

From f5e0f16157da6a0b0dbae3b4ebf920fdee81c461 Mon Sep 17 00:00:00 2001
From: Akhil Appana <akhil.appana@gmail.com>
Date: Fri, 8 Aug 2025 04:33:42 -0700
Subject: [PATCH 060/107] fix: properly report tool errors in telemetry (#5688)

Co-authored-by: gemini-code-assist[bot] <176961590+gemini-code-assist[bot]@users.noreply.github.com>
---
 packages/core/src/tools/read-file.test.ts  | 543 +++++++++++++--------
 packages/core/src/tools/read-file.ts       |  41 +-
 packages/core/src/tools/shell.test.ts      |  37 ++
 packages/core/src/tools/shell.ts           |   7 +-
 packages/core/src/tools/tool-error.ts      |   4 +
 packages/core/src/tools/write-file.test.ts | 137 +++++-
 packages/core/src/tools/write-file.ts      |  58 ++-
 packages/core/src/utils/fileUtils.ts       |  10 +
 8 files changed, 607 insertions(+), 230 deletions(-)

diff --git a/packages/core/src/tools/read-file.test.ts b/packages/core/src/tools/read-file.test.ts
index 8c11afab..101b74a5 100644
--- a/packages/core/src/tools/read-file.test.ts
+++ b/packages/core/src/tools/read-file.test.ts
@@ -6,6 +6,7 @@
 
 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';
@@ -47,276 +48,390 @@ describe('ReadFileTool', () => {
         absolute_path: path.join(tempRootDir, 'test.txt'),
       };
       const result = tool.build(params);
-      expect(result).not.toBeTypeOf('string');
-      expect(typeof result).toBe('object');
-      expect(
-        (result as ToolInvocation<ReadFileToolParams, ToolResult>).params,
-      ).toEqual(params);
+      expect(typeof result).not.toBe('string');
     });
 
-    it('should return an invocation for valid params with offset and limit', () => {
+    it('should throw error if file path is relative', () => {
       const params: ReadFileToolParams = {
-        absolute_path: path.join(tempRootDir, 'test.txt'),
-        offset: 0,
-        limit: 10,
+        absolute_path: 'relative/path.txt',
       };
-      const result = tool.build(params);
-      expect(result).not.toBeTypeOf('string');
-    });
-
-    it('should throw error for relative path', () => {
-      const params: ReadFileToolParams = { absolute_path: 'test.txt' };
       expect(() => tool.build(params)).toThrow(
-        `File path must be absolute, but was relative: test.txt. You must provide an absolute path.`,
+        'File path must be absolute, but was relative: relative/path.txt. You must provide an absolute path.',
       );
     });
 
-    it('should throw error for path outside root', () => {
-      const outsidePath = path.resolve(os.tmpdir(), 'outside-root.txt');
-      const params: ReadFileToolParams = { absolute_path: outsidePath };
+    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',
+        /File path must be within one of the workspace directories/,
       );
     });
 
-    it('should throw error for negative offset', () => {
+    it('should throw error if offset is negative', () => {
       const params: ReadFileToolParams = {
         absolute_path: path.join(tempRootDir, 'test.txt'),
         offset: -1,
-        limit: 10,
       };
       expect(() => tool.build(params)).toThrow(
         'Offset must be a non-negative number',
       );
     });
 
-    it('should throw error for non-positive limit', () => {
-      const paramsZero: ReadFileToolParams = {
+    it('should throw error if limit is zero or negative', () => {
+      const params: ReadFileToolParams = {
         absolute_path: path.join(tempRootDir, 'test.txt'),
-        offset: 0,
         limit: 0,
       };
-      expect(() => tool.build(paramsZero)).toThrow(
-        'Limit must be a positive number',
-      );
-      const paramsNegative: ReadFileToolParams = {
-        absolute_path: path.join(tempRootDir, 'test.txt'),
-        offset: 0,
-        limit: -5,
-      };
-      expect(() => tool.build(paramsNegative)).toThrow(
-        'Limit must be a positive number',
-      );
-    });
-
-    it('should throw error for schema validation failure (e.g. missing path)', () => {
-      const params = { offset: 0 } as unknown as ReadFileToolParams;
       expect(() => tool.build(params)).toThrow(
-        `params must have required property 'absolute_path'`,
+        'Limit must be a positive number',
       );
     });
   });
 
-  describe('ToolInvocation', () => {
-    describe('getDescription', () => {
-      it('should return a shortened, relative path', () => {
-        const filePath = path.join(tempRootDir, 'sub', 'dir', 'file.txt');
-        const params: ReadFileToolParams = { absolute_path: filePath };
-        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'));
-      });
+  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 . 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('.');
+    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,
+        },
       });
     });
 
-    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
-        >;
+    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: `File not found: ${filePath}`,
-          returnDisplay: 'File not found.',
-        });
+      expect(await invocation.execute(abortSignal)).toEqual({
+        llmContent: fileContent,
+        returnDisplay: '',
       });
+    });
 
-      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
-        >;
+    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
+      >;
 
-        expect(await invocation.execute(abortSignal)).toEqual({
-          llmContent: fileContent,
-          returnDisplay: '',
-        });
+      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 success result for an image file', async () => {
-        // A minimal 1x1 transparent PNG file.
-        const pngContent = Buffer.from([
-          137, 80, 78, 71, 13, 10, 26, 10, 0, 0, 0, 13, 73, 72, 68, 82, 0, 0, 0,
-          1, 0, 0, 0, 1, 8, 6, 0, 0, 0, 31, 21, 196, 137, 0, 0, 0, 10, 73, 68,
-          65, 84, 120, 156, 99, 0, 1, 0, 0, 5, 0, 1, 13, 10, 45, 180, 0, 0, 0,
-          0, 73, 69, 78, 68, 174, 66, 96, 130,
-        ]);
-        const filePath = path.join(tempRootDir, 'image.png');
-        await fsp.writeFile(filePath, pngContent);
-        const params: ReadFileToolParams = { absolute_path: filePath };
-        const invocation = tool.build(params) as ToolInvocation<
-          ReadFileToolParams,
-          ToolResult
-        >;
+    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
+      >;
 
-        expect(await invocation.execute(abortSignal)).toEqual({
-          llmContent: {
-            inlineData: {
-              mimeType: 'image/png',
-              data: pngContent.toString('base64'),
-            },
-          },
-          returnDisplay: `Read image file: image.png`,
-        });
+      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 treat a non-image file with image extension as an image', async () => {
-        const filePath = path.join(tempRootDir, 'fake-image.png');
-        const fileContent = 'This is not a real png.';
-        await fsp.writeFile(filePath, fileContent, 'utf-8');
-        const params: ReadFileToolParams = { absolute_path: filePath };
-        const invocation = tool.build(params) as ToolInvocation<
-          ReadFileToolParams,
-          ToolResult
-        >;
+    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
+      >;
 
-        expect(await invocation.execute(abortSignal)).toEqual({
-          llmContent: {
-            inlineData: {
-              mimeType: 'image/png',
-              data: Buffer.from(fileContent).toString('base64'),
-            },
-          },
-          returnDisplay: `Read image file: fake-image.png`,
-        });
+      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 return a structured message when a slice of a text file is read', async () => {
-        const filePath = path.join(tempRootDir, 'paginated.txt');
-        const fileContent = Array.from(
-          { length: 20 },
-          (_, i) => `Line ${i + 1}`,
-        ).join('\n');
-        await fsp.writeFile(filePath, fileContent, 'utf-8');
+    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 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).toBe(
+        'Cannot display content of binary file: binary.bin',
+      );
+      expect(result.returnDisplay).toBe('Skipped binary file: binary.bin');
+    });
 
-        const result = await invocation.execute(abortSignal);
+    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 expectedLlmContent = `
-IMPORTANT: The file content has been truncated.
-Status: Showing lines 6-8 of 20 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: 8.
+      const result = await invocation.execute(abortSignal);
+      expect(result.llmContent).toBe(svgContent);
+      expect(result.returnDisplay).toBe('Read SVG as text: image.svg');
+    });
 
---- FILE CONTENT (truncated) ---
-Line 6
-Line 7
-Line 8`;
+    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
+      >;
 
-        expect(result.llmContent).toEqual(expectedLlmContent);
-        expect(result.returnDisplay).toBe(
-          'Read lines 6-8 of 20 from paginated.txt',
+      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'),
         );
       });
 
-      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 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 throw error if path is in an ignored directory', async () => {
-          const ignoredDirPath = path.join(tempRootDir, 'ignored');
-          await fsp.mkdir(ignoredDirPath);
-          const filePath = path.join(ignoredDirPath, 'somefile.txt');
-          await fsp.writeFile(filePath, 'content', 'utf-8');
-
-          const params: ReadFileToolParams = {
-            absolute_path: filePath,
-          };
-          const expectedError = `File path '${filePath}' 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');
       });
     });
   });
-
-  describe('workspace boundary validation', () => {
-    it('should validate paths are within workspace root', () => {
-      const params: ReadFileToolParams = {
-        absolute_path: path.join(tempRootDir, 'file.txt'),
-      };
-      expect(() => tool.build(params)).not.toThrow();
-    });
-
-    it('should reject paths outside workspace root', () => {
-      const params: ReadFileToolParams = {
-        absolute_path: '/etc/passwd',
-      };
-      expect(() => tool.build(params)).toThrow(
-        'File path must be within one of the workspace directories',
-      );
-    });
-
-    it('should provide clear error message with workspace directories', () => {
-      const outsidePath = path.join(os.tmpdir(), 'outside-workspace.txt');
-      const params: ReadFileToolParams = {
-        absolute_path: outsidePath,
-      };
-      expect(() => tool.build(params)).toThrow(
-        'File path must be within one of the workspace directories',
-      );
-    });
-  });
 });
diff --git a/packages/core/src/tools/read-file.ts b/packages/core/src/tools/read-file.ts
index 4c1d044c..2ab50282 100644
--- a/packages/core/src/tools/read-file.ts
+++ b/packages/core/src/tools/read-file.ts
@@ -15,6 +15,7 @@ import {
   ToolLocation,
   ToolResult,
 } from './tools.js';
+import { ToolErrorType } from './tool-error.js';
 import { PartUnion, Type } from '@google/genai';
 import {
   processSingleFileContent,
@@ -78,9 +79,45 @@ class ReadFileToolInvocation extends BaseToolInvocation<
     );
 
     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: result.error, // The detailed error for LLM
-        returnDisplay: result.returnDisplay || 'Error reading file', // User-friendly error
+        llmContent,
+        returnDisplay: result.returnDisplay || 'Error reading file',
+        error: {
+          message: result.error,
+          type: errorType,
+        },
       };
     }
 
diff --git a/packages/core/src/tools/shell.test.ts b/packages/core/src/tools/shell.test.ts
index 7f237e3d..55720af5 100644
--- a/packages/core/src/tools/shell.test.ts
+++ b/packages/core/src/tools/shell.test.ts
@@ -25,6 +25,7 @@ vi.mock('../utils/summarizer.js');
 
 import { isCommandAllowed } from '../utils/shell-utils.js';
 import { ShellTool } from './shell.js';
+import { ToolErrorType } from './tool-error.js';
 import { type Config } from '../config/config.js';
 import {
   type ShellExecutionResult,
@@ -203,6 +204,42 @@ describe('ShellTool', () => {
       expect(result.llmContent).not.toContain('pgrep');
     });
 
+    it('should return error with error property for invalid parameters', async () => {
+      const result = await shellTool.execute(
+        { command: '' }, // Empty command is invalid
+        mockAbortSignal,
+      );
+
+      expect(result.llmContent).toContain(
+        'Could not execute command due to invalid parameters:',
+      );
+      expect(result.returnDisplay).toBe('Command cannot be empty.');
+      expect(result.error).toEqual({
+        message: 'Command cannot be empty.',
+        type: ToolErrorType.INVALID_TOOL_PARAMS,
+      });
+    });
+
+    it('should return error with error property for invalid directory', async () => {
+      vi.mocked(fs.existsSync).mockReturnValue(false);
+      const result = await shellTool.execute(
+        { command: 'ls', directory: 'nonexistent' },
+        mockAbortSignal,
+      );
+
+      expect(result.llmContent).toContain(
+        'Could not execute command due to invalid parameters:',
+      );
+      expect(result.returnDisplay).toBe(
+        "Directory 'nonexistent' is not a registered workspace directory.",
+      );
+      expect(result.error).toEqual({
+        message:
+          "Directory 'nonexistent' is not a registered workspace directory.",
+        type: ToolErrorType.INVALID_TOOL_PARAMS,
+      });
+    });
+
     it('should summarize output when configured', async () => {
       (mockConfig.getSummarizeToolOutputConfig as Mock).mockReturnValue({
         [shellTool.name]: { tokenBudget: 1000 },
diff --git a/packages/core/src/tools/shell.ts b/packages/core/src/tools/shell.ts
index 96423af1..6106c0cd 100644
--- a/packages/core/src/tools/shell.ts
+++ b/packages/core/src/tools/shell.ts
@@ -17,6 +17,7 @@ import {
   ToolConfirmationOutcome,
   Icon,
 } from './tools.js';
+import { ToolErrorType } from './tool-error.js';
 import { Type } from '@google/genai';
 import { SchemaValidator } from '../utils/schemaValidator.js';
 import { getErrorMessage } from '../utils/errors.js';
@@ -186,8 +187,12 @@ export class ShellTool extends BaseTool<ShellToolParams, ToolResult> {
     });
     if (validationError) {
       return {
-        llmContent: validationError,
+        llmContent: `Could not execute command due to invalid parameters: ${validationError}`,
         returnDisplay: validationError,
+        error: {
+          message: validationError,
+          type: ToolErrorType.INVALID_TOOL_PARAMS,
+        },
       };
     }
 
diff --git a/packages/core/src/tools/tool-error.ts b/packages/core/src/tools/tool-error.ts
index 38caa1da..2702de02 100644
--- a/packages/core/src/tools/tool-error.ts
+++ b/packages/core/src/tools/tool-error.ts
@@ -19,6 +19,10 @@ export enum ToolErrorType {
   FILE_WRITE_FAILURE = 'file_write_failure',
   READ_CONTENT_FAILURE = 'read_content_failure',
   ATTEMPT_TO_CREATE_EXISTING_FILE = 'attempt_to_create_existing_file',
+  FILE_TOO_LARGE = 'file_too_large',
+  PERMISSION_DENIED = 'permission_denied',
+  NO_SPACE_LEFT = 'no_space_left',
+  TARGET_IS_DIRECTORY = 'target_is_directory',
 
   // Edit-specific Errors
   EDIT_PREPARATION_FAILURE = 'edit_preparation_failure',
diff --git a/packages/core/src/tools/write-file.test.ts b/packages/core/src/tools/write-file.test.ts
index 563579bb..1967b99b 100644
--- a/packages/core/src/tools/write-file.test.ts
+++ b/packages/core/src/tools/write-file.test.ts
@@ -14,6 +14,7 @@ import {
   type Mocked,
 } from 'vitest';
 import { WriteFileTool, WriteFileToolParams } from './write-file.js';
+import { ToolErrorType } from './tool-error.js';
 import {
   FileDiff,
   ToolConfirmationOutcome,
@@ -464,18 +465,27 @@ describe('WriteFileTool', () => {
     it('should return error if params are invalid (relative path)', async () => {
       const params = { file_path: 'relative.txt', content: 'test' };
       const result = await tool.execute(params, abortSignal);
-      expect(result.llmContent).toMatch(/Error: Invalid parameters provided/);
-      expect(result.returnDisplay).toMatch(/Error: File path must be absolute/);
+      expect(result.llmContent).toContain(
+        'Could not write file due to invalid parameters:',
+      );
+      expect(result.returnDisplay).toMatch(/File path must be absolute/);
+      expect(result.error).toEqual({
+        message: 'File path must be absolute: relative.txt',
+        type: ToolErrorType.INVALID_TOOL_PARAMS,
+      });
     });
 
     it('should return error if params are invalid (path outside root)', async () => {
       const outsidePath = path.resolve(tempDir, 'outside-root.txt');
       const params = { file_path: outsidePath, content: 'test' };
       const result = await tool.execute(params, abortSignal);
-      expect(result.llmContent).toMatch(/Error: Invalid parameters provided/);
-      expect(result.returnDisplay).toContain(
-        'Error: File path must be within one of the workspace directories',
+      expect(result.llmContent).toContain(
+        'Could not write file due to invalid parameters:',
       );
+      expect(result.returnDisplay).toContain(
+        'File path must be within one of the workspace directories',
+      );
+      expect(result.error?.type).toBe(ToolErrorType.INVALID_TOOL_PARAMS);
     });
 
     it('should return error if _getCorrectedFileContent returns an error during execute', async () => {
@@ -490,10 +500,15 @@ describe('WriteFileTool', () => {
       });
 
       const result = await tool.execute(params, abortSignal);
-      expect(result.llmContent).toMatch(/Error checking existing file/);
+      expect(result.llmContent).toContain('Error checking existing file:');
       expect(result.returnDisplay).toMatch(
         /Error checking existing file: Simulated read error for execute/,
       );
+      expect(result.error).toEqual({
+        message:
+          'Error checking existing file: Simulated read error for execute',
+        type: ToolErrorType.FILE_WRITE_FAILURE,
+      });
 
       vi.spyOn(fs, 'readFileSync').mockImplementation(originalReadFileSync);
       fs.chmodSync(filePath, 0o600);
@@ -709,4 +724,114 @@ describe('WriteFileTool', () => {
       expect(error).toContain(rootDir);
     });
   });
+
+  describe('specific error types for write failures', () => {
+    const abortSignal = new AbortController().signal;
+
+    it('should return PERMISSION_DENIED error when write fails with EACCES', async () => {
+      const filePath = path.join(rootDir, 'permission_denied_file.txt');
+      const content = 'test content';
+
+      // Mock writeFileSync to throw EACCES error
+      const originalWriteFileSync = fs.writeFileSync;
+      vi.spyOn(fs, 'writeFileSync').mockImplementationOnce(() => {
+        const error = new Error('Permission denied') as NodeJS.ErrnoException;
+        error.code = 'EACCES';
+        throw error;
+      });
+
+      const params = { file_path: filePath, content };
+      const result = await tool.execute(params, abortSignal);
+
+      expect(result.error?.type).toBe(ToolErrorType.PERMISSION_DENIED);
+      expect(result.llmContent).toContain(
+        `Permission denied writing to file: ${filePath} (EACCES)`,
+      );
+      expect(result.returnDisplay).toContain('Permission denied');
+
+      vi.spyOn(fs, 'writeFileSync').mockImplementation(originalWriteFileSync);
+    });
+
+    it('should return NO_SPACE_LEFT error when write fails with ENOSPC', async () => {
+      const filePath = path.join(rootDir, 'no_space_file.txt');
+      const content = 'test content';
+
+      // Mock writeFileSync to throw ENOSPC error
+      const originalWriteFileSync = fs.writeFileSync;
+      vi.spyOn(fs, 'writeFileSync').mockImplementationOnce(() => {
+        const error = new Error(
+          'No space left on device',
+        ) as NodeJS.ErrnoException;
+        error.code = 'ENOSPC';
+        throw error;
+      });
+
+      const params = { file_path: filePath, content };
+      const result = await tool.execute(params, abortSignal);
+
+      expect(result.error?.type).toBe(ToolErrorType.NO_SPACE_LEFT);
+      expect(result.llmContent).toContain(
+        `No space left on device: ${filePath} (ENOSPC)`,
+      );
+      expect(result.returnDisplay).toContain('No space left');
+
+      vi.spyOn(fs, 'writeFileSync').mockImplementation(originalWriteFileSync);
+    });
+
+    it('should return TARGET_IS_DIRECTORY error when write fails with EISDIR', async () => {
+      const dirPath = path.join(rootDir, 'test_directory');
+      const content = 'test content';
+
+      // Mock fs.existsSync to return false to bypass validation
+      const originalExistsSync = fs.existsSync;
+      vi.spyOn(fs, 'existsSync').mockImplementation((path) => {
+        if (path === dirPath) {
+          return false; // Pretend directory doesn't exist to bypass validation
+        }
+        return originalExistsSync(path as string);
+      });
+
+      // Mock writeFileSync to throw EISDIR error
+      const originalWriteFileSync = fs.writeFileSync;
+      vi.spyOn(fs, 'writeFileSync').mockImplementationOnce(() => {
+        const error = new Error('Is a directory') as NodeJS.ErrnoException;
+        error.code = 'EISDIR';
+        throw error;
+      });
+
+      const params = { file_path: dirPath, content };
+      const result = await tool.execute(params, abortSignal);
+
+      expect(result.error?.type).toBe(ToolErrorType.TARGET_IS_DIRECTORY);
+      expect(result.llmContent).toContain(
+        `Target is a directory, not a file: ${dirPath} (EISDIR)`,
+      );
+      expect(result.returnDisplay).toContain('Target is a directory');
+
+      vi.spyOn(fs, 'existsSync').mockImplementation(originalExistsSync);
+      vi.spyOn(fs, 'writeFileSync').mockImplementation(originalWriteFileSync);
+    });
+
+    it('should return FILE_WRITE_FAILURE for generic write errors', async () => {
+      const filePath = path.join(rootDir, 'generic_error_file.txt');
+      const content = 'test content';
+
+      // Ensure fs.existsSync is not mocked for this test
+      vi.restoreAllMocks();
+
+      // Mock writeFileSync to throw generic error
+      vi.spyOn(fs, 'writeFileSync').mockImplementationOnce(() => {
+        throw new Error('Generic write error');
+      });
+
+      const params = { file_path: filePath, content };
+      const result = await tool.execute(params, abortSignal);
+
+      expect(result.error?.type).toBe(ToolErrorType.FILE_WRITE_FAILURE);
+      expect(result.llmContent).toContain(
+        'Error writing to file: Generic write error',
+      );
+      expect(result.returnDisplay).toContain('Generic write error');
+    });
+  });
 });
diff --git a/packages/core/src/tools/write-file.ts b/packages/core/src/tools/write-file.ts
index 4a9f8d35..b018d653 100644
--- a/packages/core/src/tools/write-file.ts
+++ b/packages/core/src/tools/write-file.ts
@@ -17,6 +17,7 @@ import {
   ToolCallConfirmationDetails,
   Icon,
 } from './tools.js';
+import { ToolErrorType } from './tool-error.js';
 import { Type } from '@google/genai';
 import { SchemaValidator } from '../utils/schemaValidator.js';
 import { makeRelative, shortenPath } from '../utils/paths.js';
@@ -230,8 +231,12 @@ export class WriteFileTool
     const validationError = this.validateToolParams(params);
     if (validationError) {
       return {
-        llmContent: `Error: Invalid parameters provided. Reason: ${validationError}`,
-        returnDisplay: `Error: ${validationError}`,
+        llmContent: `Could not write file due to invalid parameters: ${validationError}`,
+        returnDisplay: validationError,
+        error: {
+          message: validationError,
+          type: ToolErrorType.INVALID_TOOL_PARAMS,
+        },
       };
     }
 
@@ -243,10 +248,16 @@ export class WriteFileTool
 
     if (correctedContentResult.error) {
       const errDetails = correctedContentResult.error;
-      const errorMsg = `Error checking existing file: ${errDetails.message}`;
+      const errorMsg = errDetails.code
+        ? `Error checking existing file '${params.file_path}': ${errDetails.message} (${errDetails.code})`
+        : `Error checking existing file: ${errDetails.message}`;
       return {
-        llmContent: `Error checking existing file ${params.file_path}: ${errDetails.message}`,
+        llmContent: errorMsg,
         returnDisplay: errorMsg,
+        error: {
+          message: errorMsg,
+          type: ToolErrorType.FILE_WRITE_FAILURE,
+        },
       };
     }
 
@@ -344,10 +355,43 @@ export class WriteFileTool
         returnDisplay: displayResult,
       };
     } catch (error) {
-      const errorMsg = `Error writing to file: ${error instanceof Error ? error.message : String(error)}`;
+      // Capture detailed error information for debugging
+      let errorMsg: string;
+      let errorType = ToolErrorType.FILE_WRITE_FAILURE;
+
+      if (isNodeError(error)) {
+        // Handle specific Node.js errors with their error codes
+        errorMsg = `Error writing to file '${params.file_path}': ${error.message} (${error.code})`;
+
+        // Log specific error types for better debugging
+        if (error.code === 'EACCES') {
+          errorMsg = `Permission denied writing to file: ${params.file_path} (${error.code})`;
+          errorType = ToolErrorType.PERMISSION_DENIED;
+        } else if (error.code === 'ENOSPC') {
+          errorMsg = `No space left on device: ${params.file_path} (${error.code})`;
+          errorType = ToolErrorType.NO_SPACE_LEFT;
+        } else if (error.code === 'EISDIR') {
+          errorMsg = `Target is a directory, not a file: ${params.file_path} (${error.code})`;
+          errorType = ToolErrorType.TARGET_IS_DIRECTORY;
+        }
+
+        // Include stack trace in debug mode for better troubleshooting
+        if (this.config.getDebugMode() && error.stack) {
+          console.error('Write file error stack:', error.stack);
+        }
+      } else if (error instanceof Error) {
+        errorMsg = `Error writing to file: ${error.message}`;
+      } else {
+        errorMsg = `Error writing to file: ${String(error)}`;
+      }
+
       return {
-        llmContent: `Error writing to file ${params.file_path}: ${errorMsg}`,
-        returnDisplay: `Error: ${errorMsg}`,
+        llmContent: errorMsg,
+        returnDisplay: errorMsg,
+        error: {
+          message: errorMsg,
+          type: errorType,
+        },
       };
     }
   }
diff --git a/packages/core/src/utils/fileUtils.ts b/packages/core/src/utils/fileUtils.ts
index 30ab69c6..92186e4f 100644
--- a/packages/core/src/utils/fileUtils.ts
+++ b/packages/core/src/utils/fileUtils.ts
@@ -195,10 +195,18 @@ export async function detectFileType(
   return 'text';
 }
 
+export enum FileErrorType {
+  FILE_NOT_FOUND = 'FILE_NOT_FOUND',
+  IS_DIRECTORY = 'IS_DIRECTORY',
+  FILE_TOO_LARGE = 'FILE_TOO_LARGE',
+  READ_ERROR = 'READ_ERROR',
+}
+
 export interface ProcessedFileReadResult {
   llmContent: PartUnion; // string for text, Part for image/pdf/unreadable binary
   returnDisplay: string;
   error?: string; // Optional error message for the LLM if file processing failed
+  errorType?: FileErrorType; // Structured error type using enum
   isTruncated?: boolean; // For text files, indicates if content was truncated
   originalLineCount?: number; // For text files
   linesShown?: [number, number]; // For text files [startLine, endLine] (1-based for display)
@@ -225,6 +233,7 @@ export async function processSingleFileContent(
         llmContent: '',
         returnDisplay: 'File not found.',
         error: `File not found: ${filePath}`,
+        errorType: FileErrorType.FILE_NOT_FOUND,
       };
     }
     const stats = await fs.promises.stat(filePath);
@@ -233,6 +242,7 @@ export async function processSingleFileContent(
         llmContent: '',
         returnDisplay: 'Path is a directory.',
         error: `Path is a directory, not a file: ${filePath}`,
+        errorType: FileErrorType.IS_DIRECTORY,
       };
     }
 

From 51d09e720b7563fcd395f8e520bbc7ed365912d8 Mon Sep 17 00:00:00 2001
From: Gal Zahavi <38544478+galz10@users.noreply.github.com>
Date: Fri, 8 Aug 2025 08:10:04 -0700
Subject: [PATCH 061/107] fix(core): Add missing mnemonist dependency (#5841)

---
 package-lock.json          | 3 +--
 packages/core/package.json | 1 +
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/package-lock.json b/package-lock.json
index 150a4ebf..0ee930b4 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -7865,7 +7865,6 @@
       "version": "0.40.3",
       "resolved": "https://registry.npmjs.org/mnemonist/-/mnemonist-0.40.3.tgz",
       "integrity": "sha512-Vjyr90sJ23CKKH/qPAgUKicw/v6pRoamxIEDFOF8uSgFME7DqPRpHgRTejWVjkdGg5dXj0/NyxZHZ9bcjH+2uQ==",
-      "dev": true,
       "license": "MIT",
       "dependencies": {
         "obliterator": "^2.0.4"
@@ -8305,7 +8304,6 @@
       "version": "2.0.5",
       "resolved": "https://registry.npmjs.org/obliterator/-/obliterator-2.0.5.tgz",
       "integrity": "sha512-42CPE9AhahZRsMNslczq0ctAEtqk8Eka26QofnqC346BZdHDySk3LWka23LI7ULIw11NmltpiLagIq8gBozxTw==",
-      "dev": true,
       "license": "MIT"
     },
     "node_modules/on-finished": {
@@ -11916,6 +11914,7 @@
         "ignore": "^7.0.0",
         "marked": "^15.0.12",
         "micromatch": "^4.0.8",
+        "mnemonist": "^0.40.3",
         "open": "^10.1.2",
         "picomatch": "^4.0.1",
         "shell-quote": "^1.8.3",
diff --git a/packages/core/package.json b/packages/core/package.json
index 37e3687d..b82feb7f 100644
--- a/packages/core/package.json
+++ b/packages/core/package.json
@@ -43,6 +43,7 @@
     "ignore": "^7.0.0",
     "marked": "^15.0.12",
     "micromatch": "^4.0.8",
+    "mnemonist": "^0.40.3",
     "open": "^10.1.2",
     "picomatch": "^4.0.1",
     "shell-quote": "^1.8.3",

From 407393b1285ed648be6594395429a802e876b20c Mon Sep 17 00:00:00 2001
From: christine betts <chrstn@uw.edu>
Date: Fri, 8 Aug 2025 15:21:50 +0000
Subject: [PATCH 062/107] [ide-mode] Hide diff options when active diff is not
 focused (#5808)

Co-authored-by: Jacob Richman <jacob314@gmail.com>
---
 .../vscode-ide-companion/src/diff-manager.ts  | 28 ++++++++++++++++++-
 .../src/extension.test.ts                     |  7 +++++
 2 files changed, 34 insertions(+), 1 deletion(-)

diff --git a/packages/vscode-ide-companion/src/diff-manager.ts b/packages/vscode-ide-companion/src/diff-manager.ts
index d2a53b54..9c7afc1d 100644
--- a/packages/vscode-ide-companion/src/diff-manager.ts
+++ b/packages/vscode-ide-companion/src/diff-manager.ts
@@ -54,11 +54,25 @@ export class DiffManager {
     new vscode.EventEmitter<JSONRPCNotification>();
   readonly onDidChange = this.onDidChangeEmitter.event;
   private diffDocuments = new Map<string, DiffInfo>();
+  private readonly subscriptions: vscode.Disposable[] = [];
 
   constructor(
     private readonly log: (message: string) => void,
     private readonly diffContentProvider: DiffContentProvider,
-  ) {}
+  ) {
+    this.subscriptions.push(
+      vscode.window.onDidChangeActiveTextEditor((editor) => {
+        this.onActiveEditorChange(editor);
+      }),
+    );
+    this.onActiveEditorChange(vscode.window.activeTextEditor);
+  }
+
+  dispose() {
+    for (const subscription of this.subscriptions) {
+      subscription.dispose();
+    }
+  }
 
   /**
    * Creates and shows a new diff view.
@@ -199,6 +213,18 @@ export class DiffManager {
     );
   }
 
+  private async onActiveEditorChange(editor: vscode.TextEditor | undefined) {
+    const isVisible =
+      !!editor &&
+      editor.document.uri.scheme === DIFF_SCHEME &&
+      this.diffDocuments.has(editor.document.uri.toString());
+    await vscode.commands.executeCommand(
+      'setContext',
+      'gemini.diff.isVisible',
+      isVisible,
+    );
+  }
+
   private addDiffDocument(uri: vscode.Uri, diffInfo: DiffInfo) {
     this.diffDocuments.set(uri.toString(), diffInfo);
   }
diff --git a/packages/vscode-ide-companion/src/extension.test.ts b/packages/vscode-ide-companion/src/extension.test.ts
index 89d1821f..2b3db5ac 100644
--- a/packages/vscode-ide-companion/src/extension.test.ts
+++ b/packages/vscode-ide-companion/src/extension.test.ts
@@ -18,6 +18,13 @@ vi.mock('vscode', () => ({
       show: vi.fn(),
       sendText: vi.fn(),
     })),
+    onDidChangeActiveTextEditor: vi.fn(),
+    activeTextEditor: undefined,
+    tabGroups: {
+      all: [],
+      close: vi.fn(),
+    },
+    showTextDocument: vi.fn(),
   },
   workspace: {
     workspaceFolders: [],

From 5ec4ea9b4d425269c9e9052503ad85b5caaa976e Mon Sep 17 00:00:00 2001
From: christine betts <chrstn@uw.edu>
Date: Fri, 8 Aug 2025 15:35:47 +0000
Subject: [PATCH 063/107] [ide-mode] Wire up env variables to sandbox (#5804)

---
 packages/cli/src/utils/sandbox.ts   | 11 +++++++++++
 packages/core/src/ide/ide-client.ts | 11 ++++++++++-
 2 files changed, 21 insertions(+), 1 deletion(-)

diff --git a/packages/cli/src/utils/sandbox.ts b/packages/cli/src/utils/sandbox.ts
index 3550f45b..dfd2065f 100644
--- a/packages/cli/src/utils/sandbox.ts
+++ b/packages/cli/src/utils/sandbox.ts
@@ -614,6 +614,17 @@ export async function start_sandbox(
       args.push('--env', `COLORTERM=${process.env.COLORTERM}`);
     }
 
+    // Pass through IDE mode environment variables
+    for (const envVar of [
+      'GEMINI_CLI_IDE_SERVER_PORT',
+      'GEMINI_CLI_IDE_WORKSPACE_PATH',
+      'TERM_PROGRAM',
+    ]) {
+      if (process.env[envVar]) {
+        args.push('--env', `${envVar}=${process.env[envVar]}`);
+      }
+    }
+
     // copy VIRTUAL_ENV if under working directory
     // also mount-replace VIRTUAL_ENV directory with <project_settings>/sandbox.venv
     // sandbox can then set up this new VIRTUAL_ENV directory using sandbox.bashrc (see below)
diff --git a/packages/core/src/ide/ide-client.ts b/packages/core/src/ide/ide-client.ts
index 508dfea1..5ffcc2e3 100644
--- a/packages/core/src/ide/ide-client.ts
+++ b/packages/core/src/ide/ide-client.ts
@@ -324,7 +324,7 @@ export class IdeClient {
         version: '1.0.0',
       });
       transport = new StreamableHTTPClientTransport(
-        new URL(`http://localhost:${port}/mcp`),
+        new URL(`http://${getIdeServerHost()}:${port}/mcp`),
       );
       await this.client.connect(transport);
       this.registerClientHandlers();
@@ -345,3 +345,12 @@ export class IdeClient {
     }
   }
 }
+
+function getIdeServerHost() {
+  const isInContainer =
+    fs.existsSync('/.dockerenv') ||
+    fs.existsSync('/run/.containerenv') ||
+    !!process.env.SANDBOX ||
+    !!process.env.container;
+  return isInContainer ? 'host.docker.internal' : 'localhost';
+}

From 3af4913ef3f00de71744de551a568aa713a3beec Mon Sep 17 00:00:00 2001
From: christine betts <chrstn@uw.edu>
Date: Fri, 8 Aug 2025 15:38:30 +0000
Subject: [PATCH 064/107] [ide-mode] Close all open diffs when the CLI gets
 closed (#5792)

---
 packages/cli/src/ui/App.tsx                   |  3 +
 .../ui/hooks/slashCommandProcessor.test.ts    | 39 +++++++++++
 .../cli/src/ui/hooks/slashCommandProcessor.ts |  4 +-
 packages/cli/src/utils/cleanup.test.ts        | 68 +++++++++++++++++++
 packages/cli/src/utils/cleanup.ts             |  8 +--
 packages/core/src/config/config.ts            |  2 +-
 packages/core/src/ide/ide-client.ts           |  9 ++-
 7 files changed, 126 insertions(+), 7 deletions(-)
 create mode 100644 packages/cli/src/utils/cleanup.test.ts

diff --git a/packages/cli/src/ui/App.tsx b/packages/cli/src/ui/App.tsx
index a25b7a56..58a40b93 100644
--- a/packages/cli/src/ui/App.tsx
+++ b/packages/cli/src/ui/App.tsx
@@ -122,6 +122,9 @@ const App = ({ config, settings, startupWarnings = [], version }: AppProps) => {
 
   const [idePromptAnswered, setIdePromptAnswered] = useState(false);
   const currentIDE = config.getIdeClient().getCurrentIde();
+  useEffect(() => {
+    registerCleanup(() => config.getIdeClient().disconnect());
+  }, [config]);
   const shouldShowIdePrompt =
     config.getIdeModeFeature() &&
     currentIDE &&
diff --git a/packages/cli/src/ui/hooks/slashCommandProcessor.test.ts b/packages/cli/src/ui/hooks/slashCommandProcessor.test.ts
index a37af262..37407689 100644
--- a/packages/cli/src/ui/hooks/slashCommandProcessor.test.ts
+++ b/packages/cli/src/ui/hooks/slashCommandProcessor.test.ts
@@ -60,6 +60,14 @@ vi.mock('../contexts/SessionContext.js', () => ({
   useSessionStats: vi.fn(() => ({ stats: {} })),
 }));
 
+const { mockRunExitCleanup } = vi.hoisted(() => ({
+  mockRunExitCleanup: vi.fn(),
+}));
+
+vi.mock('../../utils/cleanup.js', () => ({
+  runExitCleanup: mockRunExitCleanup,
+}));
+
 import { act, renderHook, waitFor } from '@testing-library/react';
 import { vi, describe, it, expect, beforeEach, type Mock } from 'vitest';
 import { useSlashCommandProcessor } from './slashCommandProcessor.js';
@@ -405,6 +413,37 @@ describe('useSlashCommandProcessor', () => {
           vi.useRealTimers();
         }
       });
+
+      it('should call runExitCleanup when handling a "quit" action', async () => {
+        const quitAction = vi
+          .fn()
+          .mockResolvedValue({ type: 'quit', messages: [] });
+        const command = createTestCommand({
+          name: 'exit',
+          action: quitAction,
+        });
+        const result = setupProcessorHook([command]);
+
+        await waitFor(() =>
+          expect(result.current.slashCommands).toHaveLength(1),
+        );
+
+        vi.useFakeTimers();
+
+        try {
+          await act(async () => {
+            await result.current.handleSlashCommand('/exit');
+          });
+
+          await act(async () => {
+            await vi.advanceTimersByTimeAsync(200);
+          });
+
+          expect(mockRunExitCleanup).toHaveBeenCalledTimes(1);
+        } finally {
+          vi.useRealTimers();
+        }
+      });
     });
 
     it('should handle "submit_prompt" action returned from a file-based command', async () => {
diff --git a/packages/cli/src/ui/hooks/slashCommandProcessor.ts b/packages/cli/src/ui/hooks/slashCommandProcessor.ts
index cfe4b385..9f4bbf90 100644
--- a/packages/cli/src/ui/hooks/slashCommandProcessor.ts
+++ b/packages/cli/src/ui/hooks/slashCommandProcessor.ts
@@ -18,6 +18,7 @@ import {
   ToolConfirmationOutcome,
 } from '@google/gemini-cli-core';
 import { useSessionStats } from '../contexts/SessionContext.js';
+import { runExitCleanup } from '../../utils/cleanup.js';
 import {
   Message,
   MessageType,
@@ -370,7 +371,8 @@ export const useSlashCommandProcessor = (
                 }
                 case 'quit':
                   setQuittingMessages(result.messages);
-                  setTimeout(() => {
+                  setTimeout(async () => {
+                    await runExitCleanup();
                     process.exit(0);
                   }, 100);
                   return { type: 'handled' };
diff --git a/packages/cli/src/utils/cleanup.test.ts b/packages/cli/src/utils/cleanup.test.ts
new file mode 100644
index 00000000..0b254bac
--- /dev/null
+++ b/packages/cli/src/utils/cleanup.test.ts
@@ -0,0 +1,68 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { vi } from 'vitest';
+import { registerCleanup, runExitCleanup } from './cleanup';
+
+describe('cleanup', () => {
+  const originalCleanupFunctions = global['cleanupFunctions'];
+
+  beforeEach(() => {
+    // Isolate cleanup functions for each test
+    global['cleanupFunctions'] = [];
+  });
+
+  afterAll(() => {
+    // Restore original cleanup functions
+    global['cleanupFunctions'] = originalCleanupFunctions;
+  });
+
+  it('should run a registered synchronous function', async () => {
+    const cleanupFn = vi.fn();
+    registerCleanup(cleanupFn);
+
+    await runExitCleanup();
+
+    expect(cleanupFn).toHaveBeenCalledTimes(1);
+  });
+
+  it('should run a registered asynchronous function', async () => {
+    const cleanupFn = vi.fn().mockResolvedValue(undefined);
+    registerCleanup(cleanupFn);
+
+    await runExitCleanup();
+
+    expect(cleanupFn).toHaveBeenCalledTimes(1);
+  });
+
+  it('should run multiple registered functions', async () => {
+    const syncFn = vi.fn();
+    const asyncFn = vi.fn().mockResolvedValue(undefined);
+
+    registerCleanup(syncFn);
+    registerCleanup(asyncFn);
+
+    await runExitCleanup();
+
+    expect(syncFn).toHaveBeenCalledTimes(1);
+    expect(asyncFn).toHaveBeenCalledTimes(1);
+  });
+
+  it('should continue running cleanup functions even if one throws an error', async () => {
+    const errorFn = vi.fn(() => {
+      throw new Error('Test Error');
+    });
+    const successFn = vi.fn();
+
+    registerCleanup(errorFn);
+    registerCleanup(successFn);
+
+    await runExitCleanup();
+
+    expect(errorFn).toHaveBeenCalledTimes(1);
+    expect(successFn).toHaveBeenCalledTimes(1);
+  });
+});
diff --git a/packages/cli/src/utils/cleanup.ts b/packages/cli/src/utils/cleanup.ts
index 628b881c..1200b6da 100644
--- a/packages/cli/src/utils/cleanup.ts
+++ b/packages/cli/src/utils/cleanup.ts
@@ -8,16 +8,16 @@ import { promises as fs } from 'fs';
 import { join } from 'path';
 import { getProjectTempDir } from '@google/gemini-cli-core';
 
-const cleanupFunctions: Array<() => void> = [];
+const cleanupFunctions: Array<(() => void) | (() => Promise<void>)> = [];
 
-export function registerCleanup(fn: () => void) {
+export function registerCleanup(fn: (() => void) | (() => Promise<void>)) {
   cleanupFunctions.push(fn);
 }
 
-export function runExitCleanup() {
+export async function runExitCleanup() {
   for (const fn of cleanupFunctions) {
     try {
-      fn();
+      await fn();
     } catch (_) {
       // Ignore errors during cleanup.
     }
diff --git a/packages/core/src/config/config.ts b/packages/core/src/config/config.ts
index 473ab5a6..a06c4505 100644
--- a/packages/core/src/config/config.ts
+++ b/packages/core/src/config/config.ts
@@ -684,7 +684,7 @@ export class Config {
       await this.ideClient.connect();
       logIdeConnection(this, new IdeConnectionEvent(IdeConnectionType.SESSION));
     } else {
-      this.ideClient.disconnect();
+      await this.ideClient.disconnect();
     }
   }
 
diff --git a/packages/core/src/ide/ide-client.ts b/packages/core/src/ide/ide-client.ts
index 5ffcc2e3..6d8be7fa 100644
--- a/packages/core/src/ide/ide-client.ts
+++ b/packages/core/src/ide/ide-client.ts
@@ -175,7 +175,14 @@ export class IdeClient {
     }
   }
 
-  disconnect() {
+  async disconnect() {
+    if (this.state.status === IDEConnectionStatus.Disconnected) {
+      return;
+    }
+    for (const filePath of this.diffResponses.keys()) {
+      await this.closeDiff(filePath);
+    }
+    this.diffResponses.clear();
     this.setState(
       IDEConnectionStatus.Disconnected,
       'IDE integration disabled. To enable it again, run /ide enable.',

From 34b5dc7f289dc9af0a87d3a795e681d2415da3c9 Mon Sep 17 00:00:00 2001
From: shrutip90 <shruti.p90@gmail.com>
Date: Fri, 8 Aug 2025 11:02:27 -0700
Subject: [PATCH 065/107] Add FolderTrustDialog that shows on launch and
 enables folderTrust setting (#5815)

---
 packages/cli/src/config/config.ts             |  2 +-
 packages/cli/src/ui/App.test.tsx              | 28 +++++++
 packages/cli/src/ui/App.tsx                   |  7 ++
 .../ui/components/FolderTrustDialog.test.tsx  | 29 +++++++
 .../src/ui/components/FolderTrustDialog.tsx   | 70 +++++++++++++++++
 .../cli/src/ui/hooks/useFolderTrust.test.ts   | 78 +++++++++++++++++++
 packages/cli/src/ui/hooks/useFolderTrust.ts   | 31 ++++++++
 7 files changed, 244 insertions(+), 1 deletion(-)
 create mode 100644 packages/cli/src/ui/components/FolderTrustDialog.test.tsx
 create mode 100644 packages/cli/src/ui/components/FolderTrustDialog.tsx
 create mode 100644 packages/cli/src/ui/hooks/useFolderTrust.test.ts
 create mode 100644 packages/cli/src/ui/hooks/useFolderTrust.ts

diff --git a/packages/cli/src/config/config.ts b/packages/cli/src/config/config.ts
index 400d7432..d9460946 100644
--- a/packages/cli/src/config/config.ts
+++ b/packages/cli/src/config/config.ts
@@ -486,8 +486,8 @@ export async function loadCliConfig(
     ideModeFeature,
     chatCompression: settings.chatCompression,
     folderTrustFeature,
-    interactive,
     folderTrust,
+    interactive,
   });
 }
 
diff --git a/packages/cli/src/ui/App.test.tsx b/packages/cli/src/ui/App.test.tsx
index 577133ca..82ba4fe1 100644
--- a/packages/cli/src/ui/App.test.tsx
+++ b/packages/cli/src/ui/App.test.tsx
@@ -203,6 +203,13 @@ vi.mock('./hooks/useAuthCommand', () => ({
   })),
 }));
 
+vi.mock('./hooks/useFolderTrust', () => ({
+  useFolderTrust: vi.fn(() => ({
+    isFolderTrustDialogOpen: false,
+    handleFolderTrustSelect: vi.fn(),
+  })),
+}));
+
 vi.mock('./hooks/useLogger', () => ({
   useLogger: vi.fn(() => ({
     getPreviousUserMessages: vi.fn().mockResolvedValue([]),
@@ -1091,4 +1098,25 @@ describe('App UI', () => {
       expect(lastFrame()).toMatchSnapshot();
     });
   });
+
+  describe('FolderTrustDialog', () => {
+    it('should display the folder trust dialog when isFolderTrustDialogOpen is true', async () => {
+      const { useFolderTrust } = await import('./hooks/useFolderTrust.js');
+      vi.mocked(useFolderTrust).mockReturnValue({
+        isFolderTrustDialogOpen: true,
+        handleFolderTrustSelect: vi.fn(),
+      });
+
+      const { lastFrame, unmount } = render(
+        <App
+          config={mockConfig as unknown as ServerConfig}
+          settings={mockSettings}
+          version={mockVersion}
+        />,
+      );
+      currentUnmount = unmount;
+      await Promise.resolve();
+      expect(lastFrame()).toContain('Do you trust this folder?');
+    });
+  });
 });
diff --git a/packages/cli/src/ui/App.tsx b/packages/cli/src/ui/App.tsx
index 58a40b93..9550faa2 100644
--- a/packages/cli/src/ui/App.tsx
+++ b/packages/cli/src/ui/App.tsx
@@ -22,6 +22,7 @@ import { useGeminiStream } from './hooks/useGeminiStream.js';
 import { useLoadingIndicator } from './hooks/useLoadingIndicator.js';
 import { useThemeCommand } from './hooks/useThemeCommand.js';
 import { useAuthCommand } from './hooks/useAuthCommand.js';
+import { useFolderTrust } from './hooks/useFolderTrust.js';
 import { useEditorSettings } from './hooks/useEditorSettings.js';
 import { useSlashCommandProcessor } from './hooks/slashCommandProcessor.js';
 import { useAutoAcceptIndicator } from './hooks/useAutoAcceptIndicator.js';
@@ -36,6 +37,7 @@ import { ThemeDialog } from './components/ThemeDialog.js';
 import { AuthDialog } from './components/AuthDialog.js';
 import { AuthInProgress } from './components/AuthInProgress.js';
 import { EditorSettingsDialog } from './components/EditorSettingsDialog.js';
+import { FolderTrustDialog } from './components/FolderTrustDialog.js';
 import { ShellConfirmationDialog } from './components/ShellConfirmationDialog.js';
 import { Colors } from './colors.js';
 import { loadHierarchicalGeminiMemory } from '../config/config.js';
@@ -240,6 +242,9 @@ const App = ({ config, settings, startupWarnings = [], version }: AppProps) => {
     handleThemeHighlight,
   } = useThemeCommand(settings, setThemeError, addItem);
 
+  const { isFolderTrustDialogOpen, handleFolderTrustSelect } =
+    useFolderTrust(settings);
+
   const {
     isAuthDialogOpen,
     openAuthDialog,
@@ -905,6 +910,8 @@ const App = ({ config, settings, startupWarnings = [], version }: AppProps) => {
               description="If you select Yes, we'll install an extension that allows the CLI to access your open files and display diffs directly in VS Code."
               onComplete={handleIdePromptComplete}
             />
+          ) : isFolderTrustDialogOpen ? (
+            <FolderTrustDialog onSelect={handleFolderTrustSelect} />
           ) : shellConfirmationRequest ? (
             <ShellConfirmationDialog request={shellConfirmationRequest} />
           ) : isThemeDialogOpen ? (
diff --git a/packages/cli/src/ui/components/FolderTrustDialog.test.tsx b/packages/cli/src/ui/components/FolderTrustDialog.test.tsx
new file mode 100644
index 00000000..01394d0f
--- /dev/null
+++ b/packages/cli/src/ui/components/FolderTrustDialog.test.tsx
@@ -0,0 +1,29 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { render } from 'ink-testing-library';
+import { vi } from 'vitest';
+import { FolderTrustDialog, FolderTrustChoice } from './FolderTrustDialog.js';
+
+describe('FolderTrustDialog', () => {
+  it('should render the dialog with title and description', () => {
+    const { lastFrame } = render(<FolderTrustDialog onSelect={vi.fn()} />);
+
+    expect(lastFrame()).toContain('Do you trust this folder?');
+    expect(lastFrame()).toContain(
+      'Trusting a folder allows Gemini to execute commands it suggests.',
+    );
+  });
+
+  it('should call onSelect with DO_NOT_TRUST when escape is pressed', () => {
+    const onSelect = vi.fn();
+    const { stdin } = render(<FolderTrustDialog onSelect={onSelect} />);
+
+    stdin.write('\u001B'); // Simulate escape key
+
+    expect(onSelect).toHaveBeenCalledWith(FolderTrustChoice.DO_NOT_TRUST);
+  });
+});
diff --git a/packages/cli/src/ui/components/FolderTrustDialog.tsx b/packages/cli/src/ui/components/FolderTrustDialog.tsx
new file mode 100644
index 00000000..1918998c
--- /dev/null
+++ b/packages/cli/src/ui/components/FolderTrustDialog.tsx
@@ -0,0 +1,70 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { Box, Text, useInput } from 'ink';
+import React from 'react';
+import { Colors } from '../colors.js';
+import {
+  RadioButtonSelect,
+  RadioSelectItem,
+} from './shared/RadioButtonSelect.js';
+
+export enum FolderTrustChoice {
+  TRUST_FOLDER = 'trust_folder',
+  TRUST_PARENT = 'trust_parent',
+  DO_NOT_TRUST = 'do_not_trust',
+}
+
+interface FolderTrustDialogProps {
+  onSelect: (choice: FolderTrustChoice) => void;
+}
+
+export const FolderTrustDialog: React.FC<FolderTrustDialogProps> = ({
+  onSelect,
+}) => {
+  useInput((_, key) => {
+    if (key.escape) {
+      onSelect(FolderTrustChoice.DO_NOT_TRUST);
+    }
+  });
+
+  const options: Array<RadioSelectItem<FolderTrustChoice>> = [
+    {
+      label: 'Trust folder',
+      value: FolderTrustChoice.TRUST_FOLDER,
+    },
+    {
+      label: 'Trust parent folder',
+      value: FolderTrustChoice.TRUST_PARENT,
+    },
+    {
+      label: "Don't trust (esc)",
+      value: FolderTrustChoice.DO_NOT_TRUST,
+    },
+  ];
+
+  return (
+    <Box
+      flexDirection="column"
+      borderStyle="round"
+      borderColor={Colors.AccentYellow}
+      padding={1}
+      width="100%"
+      marginLeft={1}
+    >
+      <Box flexDirection="column" marginBottom={1}>
+        <Text bold>Do you trust this folder?</Text>
+        <Text>
+          Trusting a folder allows Gemini to execute commands it suggests. This
+          is a security feature to prevent accidental execution in untrusted
+          directories.
+        </Text>
+      </Box>
+
+      <RadioButtonSelect items={options} onSelect={onSelect} isFocused />
+    </Box>
+  );
+};
diff --git a/packages/cli/src/ui/hooks/useFolderTrust.test.ts b/packages/cli/src/ui/hooks/useFolderTrust.test.ts
new file mode 100644
index 00000000..61552af0
--- /dev/null
+++ b/packages/cli/src/ui/hooks/useFolderTrust.test.ts
@@ -0,0 +1,78 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { renderHook, act } from '@testing-library/react';
+import { vi } from 'vitest';
+import { useFolderTrust } from './useFolderTrust.js';
+import { LoadedSettings, SettingScope } from '../../config/settings.js';
+import { FolderTrustChoice } from '../components/FolderTrustDialog.js';
+
+describe('useFolderTrust', () => {
+  it('should set isFolderTrustDialogOpen to true when folderTrustFeature is true and folderTrust is undefined', () => {
+    const settings = {
+      merged: {
+        folderTrustFeature: true,
+        folderTrust: undefined,
+      },
+      setValue: vi.fn(),
+    } as unknown as LoadedSettings;
+
+    const { result } = renderHook(() => useFolderTrust(settings));
+
+    expect(result.current.isFolderTrustDialogOpen).toBe(true);
+  });
+
+  it('should set isFolderTrustDialogOpen to false when folderTrustFeature is false', () => {
+    const settings = {
+      merged: {
+        folderTrustFeature: false,
+        folderTrust: undefined,
+      },
+      setValue: vi.fn(),
+    } as unknown as LoadedSettings;
+
+    const { result } = renderHook(() => useFolderTrust(settings));
+
+    expect(result.current.isFolderTrustDialogOpen).toBe(false);
+  });
+
+  it('should set isFolderTrustDialogOpen to false when folderTrust is defined', () => {
+    const settings = {
+      merged: {
+        folderTrustFeature: true,
+        folderTrust: true,
+      },
+      setValue: vi.fn(),
+    } as unknown as LoadedSettings;
+
+    const { result } = renderHook(() => useFolderTrust(settings));
+
+    expect(result.current.isFolderTrustDialogOpen).toBe(false);
+  });
+
+  it('should call setValue and set isFolderTrustDialogOpen to false on handleFolderTrustSelect', () => {
+    const settings = {
+      merged: {
+        folderTrustFeature: true,
+        folderTrust: undefined,
+      },
+      setValue: vi.fn(),
+    } as unknown as LoadedSettings;
+
+    const { result } = renderHook(() => useFolderTrust(settings));
+
+    act(() => {
+      result.current.handleFolderTrustSelect(FolderTrustChoice.TRUST_FOLDER);
+    });
+
+    expect(settings.setValue).toHaveBeenCalledWith(
+      SettingScope.User,
+      'folderTrust',
+      true,
+    );
+    expect(result.current.isFolderTrustDialogOpen).toBe(false);
+  });
+});
diff --git a/packages/cli/src/ui/hooks/useFolderTrust.ts b/packages/cli/src/ui/hooks/useFolderTrust.ts
new file mode 100644
index 00000000..90a69132
--- /dev/null
+++ b/packages/cli/src/ui/hooks/useFolderTrust.ts
@@ -0,0 +1,31 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { useState, useCallback } from 'react';
+import { LoadedSettings, SettingScope } from '../../config/settings.js';
+import { FolderTrustChoice } from '../components/FolderTrustDialog.js';
+
+export const useFolderTrust = (settings: LoadedSettings) => {
+  const [isFolderTrustDialogOpen, setIsFolderTrustDialogOpen] = useState(
+    !!settings.merged.folderTrustFeature &&
+      // TODO: Update to avoid showing dialog for folders that are trusted.
+      settings.merged.folderTrust === undefined,
+  );
+
+  const handleFolderTrustSelect = useCallback(
+    (_choice: FolderTrustChoice) => {
+      // TODO: Store folderPath in the trusted folders config file based on the choice.
+      settings.setValue(SettingScope.User, 'folderTrust', true);
+      setIsFolderTrustDialogOpen(false);
+    },
+    [settings],
+  );
+
+  return {
+    isFolderTrustDialogOpen,
+    handleFolderTrustSelect,
+  };
+};

From 60bde58f29815edba365daf04c07080e8d1b24d8 Mon Sep 17 00:00:00 2001
From: shishu314 <shishu_1998@yahoo.com>
Date: Fri, 8 Aug 2025 15:58:33 -0400
Subject: [PATCH 066/107] fix(cli) - Adding logging for response and error in
 LoggingContentGenerator (#5842)

Co-authored-by: Shi Shu <shii@google.com>
---
 packages/core/src/core/geminiChat.ts          |  86 +------------
 .../core/src/core/loggingContentGenerator.ts  | 114 +++++++++++++++++-
 2 files changed, 111 insertions(+), 89 deletions(-)

diff --git a/packages/core/src/core/geminiChat.ts b/packages/core/src/core/geminiChat.ts
index 27b34d87..cef82d23 100644
--- a/packages/core/src/core/geminiChat.ts
+++ b/packages/core/src/core/geminiChat.ts
@@ -14,15 +14,12 @@ import {
   SendMessageParameters,
   createUserContent,
   Part,
-  GenerateContentResponseUsageMetadata,
   Tool,
 } from '@google/genai';
 import { retryWithBackoff } from '../utils/retry.js';
 import { isFunctionResponse } from '../utils/messageInspectors.js';
 import { ContentGenerator, AuthType } from './contentGenerator.js';
 import { Config } from '../config/config.js';
-import { logApiResponse, logApiError } from '../telemetry/loggers.js';
-import { ApiErrorEvent, ApiResponseEvent } from '../telemetry/types.js';
 import { DEFAULT_GEMINI_FLASH_MODEL } from '../config/models.js';
 import { hasCycleInSchema } from '../tools/tools.js';
 import { StructuredError } from './turn.js';
@@ -131,46 +128,6 @@ export class GeminiChat {
     validateHistory(history);
   }
 
-  private async _logApiResponse(
-    durationMs: number,
-    prompt_id: string,
-    usageMetadata?: GenerateContentResponseUsageMetadata,
-    responseText?: string,
-  ): Promise<void> {
-    logApiResponse(
-      this.config,
-      new ApiResponseEvent(
-        this.config.getModel(),
-        durationMs,
-        prompt_id,
-        this.config.getContentGeneratorConfig()?.authType,
-        usageMetadata,
-        responseText,
-      ),
-    );
-  }
-
-  private _logApiError(
-    durationMs: number,
-    error: unknown,
-    prompt_id: string,
-  ): void {
-    const errorMessage = error instanceof Error ? error.message : String(error);
-    const errorType = error instanceof Error ? error.name : 'unknown';
-
-    logApiError(
-      this.config,
-      new ApiErrorEvent(
-        this.config.getModel(),
-        errorMessage,
-        durationMs,
-        prompt_id,
-        this.config.getContentGeneratorConfig()?.authType,
-        errorType,
-      ),
-    );
-  }
-
   /**
    * Handles falling back to Flash model when persistent 429 errors occur for OAuth users.
    * Uses a fallback handler if provided by the config; otherwise, returns null.
@@ -249,7 +206,6 @@ export class GeminiChat {
     const userContent = createUserContent(params.message);
     const requestContents = this.getHistory(true).concat(userContent);
 
-    const startTime = Date.now();
     let response: GenerateContentResponse;
 
     try {
@@ -290,13 +246,6 @@ export class GeminiChat {
           await this.handleFlashFallback(authType, error),
         authType: this.config.getContentGeneratorConfig()?.authType,
       });
-      const durationMs = Date.now() - startTime;
-      await this._logApiResponse(
-        durationMs,
-        prompt_id,
-        response.usageMetadata,
-        JSON.stringify(response),
-      );
 
       this.sendPromise = (async () => {
         const outputContent = response.candidates?.[0]?.content;
@@ -324,8 +273,6 @@ export class GeminiChat {
       });
       return response;
     } catch (error) {
-      const durationMs = Date.now() - startTime;
-      this._logApiError(durationMs, error, prompt_id);
       this.sendPromise = Promise.resolve();
       throw error;
     }
@@ -361,8 +308,6 @@ export class GeminiChat {
     const userContent = createUserContent(params.message);
     const requestContents = this.getHistory(true).concat(userContent);
 
-    const startTime = Date.now();
-
     try {
       const apiCall = () => {
         const modelToUse = this.config.getModel();
@@ -413,16 +358,9 @@ export class GeminiChat {
         .then(() => undefined)
         .catch(() => undefined);
 
-      const result = this.processStreamResponse(
-        streamResponse,
-        userContent,
-        startTime,
-        prompt_id,
-      );
+      const result = this.processStreamResponse(streamResponse, userContent);
       return result;
     } catch (error) {
-      const durationMs = Date.now() - startTime;
-      this._logApiError(durationMs, error, prompt_id);
       this.sendPromise = Promise.resolve();
       throw error;
     }
@@ -483,17 +421,6 @@ export class GeminiChat {
     this.generationConfig.tools = tools;
   }
 
-  getFinalUsageMetadata(
-    chunks: GenerateContentResponse[],
-  ): GenerateContentResponseUsageMetadata | undefined {
-    const lastChunkWithMetadata = chunks
-      .slice()
-      .reverse()
-      .find((chunk) => chunk.usageMetadata);
-
-    return lastChunkWithMetadata?.usageMetadata;
-  }
-
   async maybeIncludeSchemaDepthContext(error: StructuredError): Promise<void> {
     // Check for potentially problematic cyclic tools with cyclic schemas
     // and include a recommendation to remove potentially problematic tools.
@@ -525,8 +452,6 @@ export class GeminiChat {
   private async *processStreamResponse(
     streamResponse: AsyncGenerator<GenerateContentResponse>,
     inputContent: Content,
-    startTime: number,
-    prompt_id: string,
   ) {
     const outputContent: Content[] = [];
     const chunks: GenerateContentResponse[] = [];
@@ -549,25 +474,16 @@ export class GeminiChat {
       }
     } catch (error) {
       errorOccurred = true;
-      const durationMs = Date.now() - startTime;
-      this._logApiError(durationMs, error, prompt_id);
       throw error;
     }
 
     if (!errorOccurred) {
-      const durationMs = Date.now() - startTime;
       const allParts: Part[] = [];
       for (const content of outputContent) {
         if (content.parts) {
           allParts.push(...content.parts);
         }
       }
-      await this._logApiResponse(
-        durationMs,
-        prompt_id,
-        this.getFinalUsageMetadata(chunks),
-        JSON.stringify(chunks),
-      );
     }
     this.recordHistory(inputContent, outputContent);
   }
diff --git a/packages/core/src/core/loggingContentGenerator.ts b/packages/core/src/core/loggingContentGenerator.ts
index c9069bab..305b19a4 100644
--- a/packages/core/src/core/loggingContentGenerator.ts
+++ b/packages/core/src/core/loggingContentGenerator.ts
@@ -11,11 +11,20 @@ import {
   EmbedContentParameters,
   EmbedContentResponse,
   GenerateContentParameters,
+  GenerateContentResponseUsageMetadata,
   GenerateContentResponse,
 } from '@google/genai';
-import { ApiRequestEvent } from '../telemetry/types.js';
+import {
+  ApiRequestEvent,
+  ApiResponseEvent,
+  ApiErrorEvent,
+} from '../telemetry/types.js';
 import { Config } from '../config/config.js';
-import { logApiRequest } from '../telemetry/loggers.js';
+import {
+  logApiError,
+  logApiRequest,
+  logApiResponse,
+} from '../telemetry/loggers.js';
 import { ContentGenerator } from './contentGenerator.js';
 import { toContents } from '../code_assist/converter.js';
 
@@ -40,20 +49,117 @@ export class LoggingContentGenerator implements ContentGenerator {
     );
   }
 
+  private _logApiResponse(
+    durationMs: number,
+    prompt_id: string,
+    usageMetadata?: GenerateContentResponseUsageMetadata,
+    responseText?: string,
+  ): void {
+    logApiResponse(
+      this.config,
+      new ApiResponseEvent(
+        this.config.getModel(),
+        durationMs,
+        prompt_id,
+        this.config.getContentGeneratorConfig()?.authType,
+        usageMetadata,
+        responseText,
+      ),
+    );
+  }
+
+  private _logApiError(
+    durationMs: number,
+    error: unknown,
+    prompt_id: string,
+  ): void {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    const errorType = error instanceof Error ? error.name : 'unknown';
+
+    logApiError(
+      this.config,
+      new ApiErrorEvent(
+        this.config.getModel(),
+        errorMessage,
+        durationMs,
+        prompt_id,
+        this.config.getContentGeneratorConfig()?.authType,
+        errorType,
+      ),
+    );
+  }
+
   async generateContent(
     req: GenerateContentParameters,
     userPromptId: string,
   ): Promise<GenerateContentResponse> {
+    const startTime = Date.now();
     this.logApiRequest(toContents(req.contents), req.model, userPromptId);
-    return this.wrapped.generateContent(req, userPromptId);
+    try {
+      const response = await this.wrapped.generateContent(req, userPromptId);
+      const durationMs = Date.now() - startTime;
+      this._logApiResponse(
+        durationMs,
+        userPromptId,
+        response.usageMetadata,
+        JSON.stringify(response),
+      );
+      return response;
+    } catch (error) {
+      const durationMs = Date.now() - startTime;
+      this._logApiError(durationMs, error, userPromptId);
+      throw error;
+    }
   }
 
   async generateContentStream(
     req: GenerateContentParameters,
     userPromptId: string,
   ): Promise<AsyncGenerator<GenerateContentResponse>> {
+    const startTime = Date.now();
     this.logApiRequest(toContents(req.contents), req.model, userPromptId);
-    return this.wrapped.generateContentStream(req, userPromptId);
+
+    let stream: AsyncGenerator<GenerateContentResponse>;
+    try {
+      stream = await this.wrapped.generateContentStream(req, userPromptId);
+    } catch (error) {
+      const durationMs = Date.now() - startTime;
+      this._logApiError(durationMs, error, userPromptId);
+      throw error;
+    }
+
+    return this.loggingStreamWrapper(stream, startTime, userPromptId);
+  }
+
+  private async *loggingStreamWrapper(
+    stream: AsyncGenerator<GenerateContentResponse>,
+    startTime: number,
+    userPromptId: string,
+  ): AsyncGenerator<GenerateContentResponse> {
+    let lastResponse: GenerateContentResponse | undefined;
+    let lastUsageMetadata: GenerateContentResponseUsageMetadata | undefined;
+    try {
+      for await (const response of stream) {
+        lastResponse = response;
+        if (response.usageMetadata) {
+          lastUsageMetadata = response.usageMetadata;
+        }
+        yield response;
+      }
+    } catch (error) {
+      const durationMs = Date.now() - startTime;
+      this._logApiError(durationMs, error, userPromptId);
+      throw error;
+    }
+    const durationMs = Date.now() - startTime;
+    if (lastResponse) {
+      this._logApiResponse(
+        durationMs,
+        userPromptId,
+        lastUsageMetadata,
+        JSON.stringify(lastResponse),
+      );
+    }
   }
 
   async countTokens(req: CountTokensParameters): Promise<CountTokensResponse> {

From 344ee29f7713b6a249e510674c7410d0fb8ec2f8 Mon Sep 17 00:00:00 2001
From: Shreya Keshive <skeshive@gmail.com>
Date: Fri, 8 Aug 2025 17:26:11 -0400
Subject: [PATCH 067/107] Use slash command instead of context drawer to
 display open files in editor to reduce flickering in the UI (#5858)

---
 packages/cli/src/ui/App.tsx                   | 15 +---
 .../cli/src/ui/commands/ideCommand.test.ts    | 28 ++++---
 packages/cli/src/ui/commands/ideCommand.ts    | 75 ++++++++++++++++++-
 .../IDEContextDetailDisplay.test.tsx          | 66 ----------------
 .../ui/components/IDEContextDetailDisplay.tsx | 66 ----------------
 5 files changed, 90 insertions(+), 160 deletions(-)
 delete mode 100644 packages/cli/src/ui/components/IDEContextDetailDisplay.test.tsx
 delete mode 100644 packages/cli/src/ui/components/IDEContextDetailDisplay.tsx

diff --git a/packages/cli/src/ui/App.tsx b/packages/cli/src/ui/App.tsx
index 9550faa2..9f18fe55 100644
--- a/packages/cli/src/ui/App.tsx
+++ b/packages/cli/src/ui/App.tsx
@@ -48,7 +48,6 @@ import { registerCleanup } from '../utils/cleanup.js';
 import { DetailedMessagesDisplay } from './components/DetailedMessagesDisplay.js';
 import { HistoryItemDisplay } from './components/HistoryItemDisplay.js';
 import { ContextSummaryDisplay } from './components/ContextSummaryDisplay.js';
-import { IDEContextDetailDisplay } from './components/IDEContextDetailDisplay.js';
 import { useHistory } from './hooks/useHistoryManager.js';
 import process from 'node:process';
 import {
@@ -174,8 +173,7 @@ const App = ({ config, settings, startupWarnings = [], version }: AppProps) => {
   const [showErrorDetails, setShowErrorDetails] = useState<boolean>(false);
   const [showToolDescriptions, setShowToolDescriptions] =
     useState<boolean>(false);
-  const [showIDEContextDetail, setShowIDEContextDetail] =
-    useState<boolean>(false);
+
   const [ctrlCPressedOnce, setCtrlCPressedOnce] = useState(false);
   const [quittingMessages, setQuittingMessages] = useState<
     HistoryItem[] | null
@@ -640,7 +638,7 @@ const App = ({ config, settings, startupWarnings = [], version }: AppProps) => {
       config.getIdeMode() &&
       ideContextState
     ) {
-      setShowIDEContextDetail((prev) => !prev);
+      handleSlashCommand('/ide status');
     } else if (key.ctrl && (input === 'c' || input === 'C')) {
       if (isAuthenticating) {
         // Let AuthInProgress component handle the input.
@@ -1040,14 +1038,7 @@ const App = ({ config, settings, startupWarnings = [], version }: AppProps) => {
                   {shellModeActive && <ShellModeIndicator />}
                 </Box>
               </Box>
-              {showIDEContextDetail && (
-                <IDEContextDetailDisplay
-                  ideContext={ideContextState}
-                  detectedIdeDisplay={config
-                    .getIdeClient()
-                    .getDetectedIdeDisplayName()}
-                />
-              )}
+
               {showErrorDetails && (
                 <OverflowProvider>
                   <Box flexDirection="column">
diff --git a/packages/cli/src/ui/commands/ideCommand.test.ts b/packages/cli/src/ui/commands/ideCommand.test.ts
index 9898b1e8..10a97e2a 100644
--- a/packages/cli/src/ui/commands/ideCommand.test.ts
+++ b/packages/cli/src/ui/commands/ideCommand.test.ts
@@ -93,13 +93,14 @@ describe('ideCommand', () => {
       } as unknown as ReturnType<Config['getIdeClient']>);
     });
 
-    it('should show connected status', () => {
+    it('should show connected status', async () => {
       mockGetConnectionStatus.mockReturnValue({
         status: core.IDEConnectionStatus.Connected,
       });
       const command = ideCommand(mockConfig);
-      const result = command!.subCommands!.find((c) => c.name === 'status')!
-        .action!(mockContext, '');
+      const result = await command!.subCommands!.find(
+        (c) => c.name === 'status',
+      )!.action!(mockContext, '');
       expect(mockGetConnectionStatus).toHaveBeenCalled();
       expect(result).toEqual({
         type: 'message',
@@ -108,13 +109,14 @@ describe('ideCommand', () => {
       });
     });
 
-    it('should show connecting status', () => {
+    it('should show connecting status', async () => {
       mockGetConnectionStatus.mockReturnValue({
         status: core.IDEConnectionStatus.Connecting,
       });
       const command = ideCommand(mockConfig);
-      const result = command!.subCommands!.find((c) => c.name === 'status')!
-        .action!(mockContext, '');
+      const result = await command!.subCommands!.find(
+        (c) => c.name === 'status',
+      )!.action!(mockContext, '');
       expect(mockGetConnectionStatus).toHaveBeenCalled();
       expect(result).toEqual({
         type: 'message',
@@ -122,13 +124,14 @@ describe('ideCommand', () => {
         content: `🟡 Connecting...`,
       });
     });
-    it('should show disconnected status', () => {
+    it('should show disconnected status', async () => {
       mockGetConnectionStatus.mockReturnValue({
         status: core.IDEConnectionStatus.Disconnected,
       });
       const command = ideCommand(mockConfig);
-      const result = command!.subCommands!.find((c) => c.name === 'status')!
-        .action!(mockContext, '');
+      const result = await command!.subCommands!.find(
+        (c) => c.name === 'status',
+      )!.action!(mockContext, '');
       expect(mockGetConnectionStatus).toHaveBeenCalled();
       expect(result).toEqual({
         type: 'message',
@@ -137,15 +140,16 @@ describe('ideCommand', () => {
       });
     });
 
-    it('should show disconnected status with details', () => {
+    it('should show disconnected status with details', async () => {
       const details = 'Something went wrong';
       mockGetConnectionStatus.mockReturnValue({
         status: core.IDEConnectionStatus.Disconnected,
         details,
       });
       const command = ideCommand(mockConfig);
-      const result = command!.subCommands!.find((c) => c.name === 'status')!
-        .action!(mockContext, '');
+      const result = await command!.subCommands!.find(
+        (c) => c.name === 'status',
+      )!.action!(mockContext, '');
       expect(mockGetConnectionStatus).toHaveBeenCalled();
       expect(result).toEqual({
         type: 'message',
diff --git a/packages/cli/src/ui/commands/ideCommand.ts b/packages/cli/src/ui/commands/ideCommand.ts
index fe9f764a..29e264d4 100644
--- a/packages/cli/src/ui/commands/ideCommand.ts
+++ b/packages/cli/src/ui/commands/ideCommand.ts
@@ -11,7 +11,10 @@ import {
   getIdeDisplayName,
   getIdeInstaller,
   IdeClient,
+  type File,
+  ideContext,
 } from '@google/gemini-cli-core';
+import path from 'node:path';
 import {
   CommandContext,
   SlashCommand,
@@ -49,6 +52,70 @@ function getIdeStatusMessage(ideClient: IdeClient): {
   }
 }
 
+function formatFileList(openFiles: File[]): string {
+  const basenameCounts = new Map<string, number>();
+  for (const file of openFiles) {
+    const basename = path.basename(file.path);
+    basenameCounts.set(basename, (basenameCounts.get(basename) || 0) + 1);
+  }
+
+  const fileList = openFiles
+    .map((file: File) => {
+      const basename = path.basename(file.path);
+      const isDuplicate = (basenameCounts.get(basename) || 0) > 1;
+      const parentDir = path.basename(path.dirname(file.path));
+      const displayName = isDuplicate
+        ? `${basename} (/${parentDir})`
+        : basename;
+
+      return `  - ${displayName}${file.isActive ? ' (active)' : ''}`;
+    })
+    .join('\n');
+
+  return `\n\nOpen files:\n${fileList}`;
+}
+
+async function getIdeStatusMessageWithFiles(ideClient: IdeClient): Promise<{
+  messageType: 'info' | 'error';
+  content: string;
+}> {
+  const connection = ideClient.getConnectionStatus();
+  switch (connection.status) {
+    case IDEConnectionStatus.Connected: {
+      let content = `🟢 Connected to ${ideClient.getDetectedIdeDisplayName()}`;
+      try {
+        const context = await ideContext.getIdeContext();
+        const openFiles = context?.workspaceState?.openFiles;
+
+        if (openFiles && openFiles.length > 0) {
+          content += formatFileList(openFiles);
+        }
+      } catch (_e) {
+        // Ignore
+      }
+      return {
+        messageType: 'info',
+        content,
+      };
+    }
+    case IDEConnectionStatus.Connecting:
+      return {
+        messageType: 'info',
+        content: `🟡 Connecting...`,
+      };
+    default: {
+      let content = `🔴 Disconnected`;
+      if (connection?.details) {
+        content += `: ${connection.details}`;
+      }
+      return {
+        messageType: 'error',
+        content,
+      };
+    }
+  }
+}
+
 export const ideCommand = (config: Config | null): SlashCommand | null => {
   if (!config || !config.getIdeModeFeature()) {
     return null;
@@ -66,8 +133,7 @@ export const ideCommand = (config: Config | null): SlashCommand | null => {
           messageType: 'error',
           content: `IDE integration is not supported in your current environment. To use this feature, run Gemini CLI in one of these supported IDEs: ${Object.values(
             DetectedIde,
-          )
-            .map((ide) => getIdeDisplayName(ide))
+          ).map((ide) => getIdeDisplayName(ide))}
             .join(', ')}`,
         }) as const,
     };
@@ -84,8 +150,9 @@ export const ideCommand = (config: Config | null): SlashCommand | null => {
     name: 'status',
     description: 'check status of IDE integration',
     kind: CommandKind.BUILT_IN,
-    action: (): SlashCommandActionReturn => {
-      const { messageType, content } = getIdeStatusMessage(ideClient);
+    action: async (): Promise<SlashCommandActionReturn> => {
+      const { messageType, content } =
+        await getIdeStatusMessageWithFiles(ideClient);
       return {
         type: 'message',
         messageType,
diff --git a/packages/cli/src/ui/components/IDEContextDetailDisplay.test.tsx b/packages/cli/src/ui/components/IDEContextDetailDisplay.test.tsx
deleted file mode 100644
index 629d6c2e..00000000
--- a/packages/cli/src/ui/components/IDEContextDetailDisplay.test.tsx
+++ /dev/null
@@ -1,66 +0,0 @@
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import { render } from 'ink-testing-library';
-import { describe, it, expect } from 'vitest';
-import { IDEContextDetailDisplay } from './IDEContextDetailDisplay.js';
-import { type IdeContext } from '@google/gemini-cli-core';
-
-describe('IDEContextDetailDisplay', () => {
-  it('renders an empty string when there are no open files', () => {
-    const ideContext: IdeContext = {
-      workspaceState: {
-        openFiles: [],
-      },
-    };
-    const { lastFrame } = render(
-      <IDEContextDetailDisplay
-        ideContext={ideContext}
-        detectedIdeDisplay="VS Code"
-      />,
-    );
-    expect(lastFrame()).toBe('');
-  });
-
-  it('renders a list of open files with active status', () => {
-    const ideContext: IdeContext = {
-      workspaceState: {
-        openFiles: [
-          { path: '/foo/bar.txt', isActive: true },
-          { path: '/foo/baz.txt', isActive: false },
-        ],
-      },
-    };
-    const { lastFrame } = render(
-      <IDEContextDetailDisplay
-        ideContext={ideContext}
-        detectedIdeDisplay="VS Code"
-      />,
-    );
-    const output = lastFrame();
-    expect(output).toMatchSnapshot();
-  });
-
-  it('handles duplicate basenames by showing path hints', () => {
-    const ideContext: IdeContext = {
-      workspaceState: {
-        openFiles: [
-          { path: '/foo/bar.txt', isActive: true },
-          { path: '/qux/bar.txt', isActive: false },
-          { path: '/foo/unique.txt', isActive: false },
-        ],
-      },
-    };
-    const { lastFrame } = render(
-      <IDEContextDetailDisplay
-        ideContext={ideContext}
-        detectedIdeDisplay="VS Code"
-      />,
-    );
-    const output = lastFrame();
-    expect(output).toMatchSnapshot();
-  });
-});
diff --git a/packages/cli/src/ui/components/IDEContextDetailDisplay.tsx b/packages/cli/src/ui/components/IDEContextDetailDisplay.tsx
deleted file mode 100644
index ec3c2dad..00000000
--- a/packages/cli/src/ui/components/IDEContextDetailDisplay.tsx
+++ /dev/null
@@ -1,66 +0,0 @@
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import { type File, type IdeContext } from '@google/gemini-cli-core';
-import { Box, Text } from 'ink';
-import path from 'node:path';
-import { Colors } from '../colors.js';
-
-interface IDEContextDetailDisplayProps {
-  ideContext: IdeContext | undefined;
-  detectedIdeDisplay: string | undefined;
-}
-
-export function IDEContextDetailDisplay({
-  ideContext,
-  detectedIdeDisplay,
-}: IDEContextDetailDisplayProps) {
-  const openFiles = ideContext?.workspaceState?.openFiles;
-  if (!openFiles || openFiles.length === 0) {
-    return null;
-  }
-
-  const basenameCounts = new Map<string, number>();
-  for (const file of openFiles) {
-    const basename = path.basename(file.path);
-    basenameCounts.set(basename, (basenameCounts.get(basename) || 0) + 1);
-  }
-
-  return (
-    <Box
-      flexDirection="column"
-      marginTop={1}
-      borderStyle="round"
-      borderColor={Colors.AccentCyan}
-      paddingX={1}
-    >
-      <Text color={Colors.AccentCyan} bold>
-        {detectedIdeDisplay ? detectedIdeDisplay : 'IDE'} Context (ctrl+e to
-        toggle)
-      </Text>
-      {openFiles.length > 0 && (
-        <Box flexDirection="column" marginTop={1}>
-          <Text bold>Open files:</Text>
-          {openFiles.map((file: File) => {
-            const basename = path.basename(file.path);
-            const isDuplicate = (basenameCounts.get(basename) || 0) > 1;
-            const parentDir = path.basename(path.dirname(file.path));
-            const displayName = isDuplicate
-              ? `${basename} (/${parentDir})`
-              : basename;
-
-            return (
-              <Text key={file.path}>
-                - {displayName}
-                {file.isActive ? ' (active)' : ''}
-              </Text>
-            );
-          })}
-        </Box>
-      )}
-    </Box>
-  );
-}

From 9ac62565a053674e701e172421455943ffc31d85 Mon Sep 17 00:00:00 2001
From: Shreya Keshive <skeshive@gmail.com>
Date: Fri, 8 Aug 2025 17:48:02 -0400
Subject: [PATCH 068/107] Fix excessive console logging + remove unnecessary
 try catch (#5860)

---
 packages/cli/src/ui/commands/ideCommand.ts | 13 ++++---------
 packages/core/src/ide/ide-client.ts        | 10 +++++-----
 2 files changed, 9 insertions(+), 14 deletions(-)

diff --git a/packages/cli/src/ui/commands/ideCommand.ts b/packages/cli/src/ui/commands/ideCommand.ts
index 29e264d4..95aa5711 100644
--- a/packages/cli/src/ui/commands/ideCommand.ts
+++ b/packages/cli/src/ui/commands/ideCommand.ts
@@ -83,15 +83,10 @@ async function getIdeStatusMessageWithFiles(ideClient: IdeClient): Promise<{
   switch (connection.status) {
     case IDEConnectionStatus.Connected: {
       let content = `🟢 Connected to ${ideClient.getDetectedIdeDisplayName()}`;
-      try {
-        const context = await ideContext.getIdeContext();
-        const openFiles = context?.workspaceState?.openFiles;
-
-        if (openFiles && openFiles.length > 0) {
-          content += formatFileList(openFiles);
-        }
-      } catch (_e) {
-        // Ignore
+      const context = ideContext.getIdeContext();
+      const openFiles = context?.workspaceState?.openFiles;
+      if (openFiles && openFiles.length > 0) {
+        content += formatFileList(openFiles);
       }
       return {
         messageType: 'info',
diff --git a/packages/core/src/ide/ide-client.ts b/packages/core/src/ide/ide-client.ts
index 6d8be7fa..69329bee 100644
--- a/packages/core/src/ide/ide-client.ts
+++ b/packages/core/src/ide/ide-client.ts
@@ -211,16 +211,16 @@ export class IdeClient {
       this.state.status === IDEConnectionStatus.Disconnected &&
       status === IDEConnectionStatus.Disconnected;
 
-    // Only update details if the state wasn't already disconnected, so that
-    // the first detail message is preserved.
+    // Only update details & log to console if the state wasn't already
+    // disconnected, so that the first detail message is preserved.
     if (!isAlreadyDisconnected) {
       this.state = { status, details };
-    }
-
-    if (status === IDEConnectionStatus.Disconnected) {
       if (logToConsole) {
         logger.error(details);
       }
+    }
+
+    if (status === IDEConnectionStatus.Disconnected) {
       logger.debug(details);
       ideContext.clearIdeContext();
     }

From 69322e12e40ca1d69af83df2fca95bf4c51b8bfd Mon Sep 17 00:00:00 2001
From: Jacob MacDonald <jakemac@google.com>
Date: Fri, 8 Aug 2025 14:50:35 -0700
Subject: [PATCH 069/107] Add a request queue to the tool scheduler (#5845)

---
 .../cli/src/ui/hooks/useReactToolScheduler.ts |   8 +-
 .../core/src/core/coreToolScheduler.test.ts   | 192 +++++++++++
 packages/core/src/core/coreToolScheduler.ts   | 317 +++++++++++-------
 3 files changed, 385 insertions(+), 132 deletions(-)

diff --git a/packages/cli/src/ui/hooks/useReactToolScheduler.ts b/packages/cli/src/ui/hooks/useReactToolScheduler.ts
index c6b802fc..93e05387 100644
--- a/packages/cli/src/ui/hooks/useReactToolScheduler.ts
+++ b/packages/cli/src/ui/hooks/useReactToolScheduler.ts
@@ -63,7 +63,7 @@ export type TrackedToolCall =
   | TrackedCancelledToolCall;
 
 export function useReactToolScheduler(
-  onComplete: (tools: CompletedToolCall[]) => void,
+  onComplete: (tools: CompletedToolCall[]) => Promise<void>,
   config: Config,
   setPendingHistoryItem: React.Dispatch<
     React.SetStateAction<HistoryItemWithoutId | null>
@@ -106,8 +106,8 @@ export function useReactToolScheduler(
   );
 
   const allToolCallsCompleteHandler: AllToolCallsCompleteHandler = useCallback(
-    (completedToolCalls) => {
-      onComplete(completedToolCalls);
+    async (completedToolCalls) => {
+      await onComplete(completedToolCalls);
     },
     [onComplete],
   );
@@ -157,7 +157,7 @@ export function useReactToolScheduler(
       request: ToolCallRequestInfo | ToolCallRequestInfo[],
       signal: AbortSignal,
     ) => {
-      scheduler.schedule(request, signal);
+      void scheduler.schedule(request, signal);
     },
     [scheduler],
   );
diff --git a/packages/core/src/core/coreToolScheduler.test.ts b/packages/core/src/core/coreToolScheduler.test.ts
index a65443f8..a3a25707 100644
--- a/packages/core/src/core/coreToolScheduler.test.ts
+++ b/packages/core/src/core/coreToolScheduler.test.ts
@@ -592,3 +592,195 @@ describe('CoreToolScheduler YOLO mode', () => {
     }
   });
 });
+
+describe('CoreToolScheduler request queueing', () => {
+  it('should queue a request if another is running', async () => {
+    let resolveFirstCall: (result: ToolResult) => void;
+    const firstCallPromise = new Promise<ToolResult>((resolve) => {
+      resolveFirstCall = resolve;
+    });
+
+    const mockTool = new MockTool();
+    mockTool.executeFn.mockImplementation(() => firstCallPromise);
+    const declarativeTool = mockTool;
+
+    const toolRegistry = {
+      getTool: () => declarativeTool,
+      getToolByName: () => declarativeTool,
+      getFunctionDeclarations: () => [],
+      tools: new Map(),
+      discovery: {} as any,
+      registerTool: () => {},
+      getToolByDisplayName: () => declarativeTool,
+      getTools: () => [],
+      discoverTools: async () => {},
+      getAllTools: () => [],
+      getToolsByServer: () => [],
+    };
+
+    const onAllToolCallsComplete = vi.fn();
+    const onToolCallsUpdate = vi.fn();
+
+    const mockConfig = {
+      getSessionId: () => 'test-session-id',
+      getUsageStatisticsEnabled: () => true,
+      getDebugMode: () => false,
+      getApprovalMode: () => ApprovalMode.YOLO, // Use YOLO to avoid confirmation prompts
+    } as unknown as Config;
+
+    const scheduler = new CoreToolScheduler({
+      config: mockConfig,
+      toolRegistry: Promise.resolve(toolRegistry as any),
+      onAllToolCallsComplete,
+      onToolCallsUpdate,
+      getPreferredEditor: () => 'vscode',
+      onEditorClose: vi.fn(),
+    });
+
+    const abortController = new AbortController();
+    const request1 = {
+      callId: '1',
+      name: 'mockTool',
+      args: { a: 1 },
+      isClientInitiated: false,
+      prompt_id: 'prompt-1',
+    };
+    const request2 = {
+      callId: '2',
+      name: 'mockTool',
+      args: { b: 2 },
+      isClientInitiated: false,
+      prompt_id: 'prompt-2',
+    };
+
+    // Schedule the first call, which will pause execution.
+    scheduler.schedule([request1], abortController.signal);
+
+    // Wait for the first call to be in the 'executing' state.
+    await vi.waitFor(() => {
+      const calls = onToolCallsUpdate.mock.calls.at(-1)?.[0] as ToolCall[];
+      expect(calls?.[0]?.status).toBe('executing');
+    });
+
+    // Schedule the second call while the first is "running".
+    const schedulePromise2 = scheduler.schedule(
+      [request2],
+      abortController.signal,
+    );
+
+    // Ensure the second tool call hasn't been executed yet.
+    expect(mockTool.executeFn).toHaveBeenCalledTimes(1);
+    expect(mockTool.executeFn).toHaveBeenCalledWith({ a: 1 });
+
+    // Complete the first tool call.
+    resolveFirstCall!({
+      llmContent: 'First call complete',
+      returnDisplay: 'First call complete',
+    });
+
+    // Wait for the second schedule promise to resolve.
+    await schedulePromise2;
+
+    // Wait for the second call to be in the 'executing' state.
+    await vi.waitFor(() => {
+      const calls = onToolCallsUpdate.mock.calls.at(-1)?.[0] as ToolCall[];
+      expect(calls?.[0]?.status).toBe('executing');
+    });
+
+    // Now the second tool call should have been executed.
+    expect(mockTool.executeFn).toHaveBeenCalledTimes(2);
+    expect(mockTool.executeFn).toHaveBeenCalledWith({ b: 2 });
+
+    // Let the second call finish.
+    const secondCallResult = {
+      llmContent: 'Second call complete',
+      returnDisplay: 'Second call complete',
+    };
+    // Since the mock is shared, we need to resolve the current promise.
+    // In a real scenario, a new promise would be created for the second call.
+    resolveFirstCall!(secondCallResult);
+
+    // Wait for the second completion.
+    await vi.waitFor(() => {
+      expect(onAllToolCallsComplete).toHaveBeenCalledTimes(2);
+    });
+
+    // Verify the completion callbacks were called correctly.
+    expect(onAllToolCallsComplete.mock.calls[0][0][0].status).toBe('success');
+    expect(onAllToolCallsComplete.mock.calls[1][0][0].status).toBe('success');
+  });
+
+  it('should handle two synchronous calls to schedule', async () => {
+    const mockTool = new MockTool();
+    const declarativeTool = mockTool;
+    const toolRegistry = {
+      getTool: () => declarativeTool,
+      getToolByName: () => declarativeTool,
+      getFunctionDeclarations: () => [],
+      tools: new Map(),
+      discovery: {} as any,
+      registerTool: () => {},
+      getToolByDisplayName: () => declarativeTool,
+      getTools: () => [],
+      discoverTools: async () => {},
+      getAllTools: () => [],
+      getToolsByServer: () => [],
+    };
+
+    const onAllToolCallsComplete = vi.fn();
+    const onToolCallsUpdate = vi.fn();
+
+    const mockConfig = {
+      getSessionId: () => 'test-session-id',
+      getUsageStatisticsEnabled: () => true,
+      getDebugMode: () => false,
+      getApprovalMode: () => ApprovalMode.YOLO,
+    } as unknown as Config;
+
+    const scheduler = new CoreToolScheduler({
+      config: mockConfig,
+      toolRegistry: Promise.resolve(toolRegistry as any),
+      onAllToolCallsComplete,
+      onToolCallsUpdate,
+      getPreferredEditor: () => 'vscode',
+      onEditorClose: vi.fn(),
+    });
+
+    const abortController = new AbortController();
+    const request1 = {
+      callId: '1',
+      name: 'mockTool',
+      args: { a: 1 },
+      isClientInitiated: false,
+      prompt_id: 'prompt-1',
+    };
+    const request2 = {
+      callId: '2',
+      name: 'mockTool',
+      args: { b: 2 },
+      isClientInitiated: false,
+      prompt_id: 'prompt-2',
+    };
+
+    // Schedule two calls synchronously.
+    const schedulePromise1 = scheduler.schedule(
+      [request1],
+      abortController.signal,
+    );
+    const schedulePromise2 = scheduler.schedule(
+      [request2],
+      abortController.signal,
+    );
+
+    // Wait for both promises to resolve.
+    await Promise.all([schedulePromise1, schedulePromise2]);
+
+    // Ensure the tool was called twice with the correct arguments.
+    expect(mockTool.executeFn).toHaveBeenCalledTimes(2);
+    expect(mockTool.executeFn).toHaveBeenCalledWith({ a: 1 });
+    expect(mockTool.executeFn).toHaveBeenCalledWith({ b: 2 });
+
+    // Ensure completion callbacks were called twice.
+    expect(onAllToolCallsComplete).toHaveBeenCalledTimes(2);
+  });
+});
diff --git a/packages/core/src/core/coreToolScheduler.ts b/packages/core/src/core/coreToolScheduler.ts
index 6f098ae3..00ff5c55 100644
--- a/packages/core/src/core/coreToolScheduler.ts
+++ b/packages/core/src/core/coreToolScheduler.ts
@@ -125,7 +125,7 @@ export type OutputUpdateHandler = (
 
 export type AllToolCallsCompleteHandler = (
   completedToolCalls: CompletedToolCall[],
-) => void;
+) => Promise<void>;
 
 export type ToolCallsUpdateHandler = (toolCalls: ToolCall[]) => void;
 
@@ -244,6 +244,14 @@ export class CoreToolScheduler {
   private getPreferredEditor: () => EditorType | undefined;
   private config: Config;
   private onEditorClose: () => void;
+  private isFinalizingToolCalls = false;
+  private isScheduling = false;
+  private requestQueue: Array<{
+    request: ToolCallRequestInfo | ToolCallRequestInfo[];
+    signal: AbortSignal;
+    resolve: () => void;
+    reject: (reason?: Error) => void;
+  }> = [];
 
   constructor(options: CoreToolSchedulerOptions) {
     this.config = options.config;
@@ -455,9 +463,12 @@ export class CoreToolScheduler {
   }
 
   private isRunning(): boolean {
-    return this.toolCalls.some(
-      (call) =>
-        call.status === 'executing' || call.status === 'awaiting_approval',
+    return (
+      this.isFinalizingToolCalls ||
+      this.toolCalls.some(
+        (call) =>
+          call.status === 'executing' || call.status === 'awaiting_approval',
+      )
     );
   }
 
@@ -475,150 +486,191 @@ export class CoreToolScheduler {
     }
   }
 
-  async schedule(
+  schedule(
     request: ToolCallRequestInfo | ToolCallRequestInfo[],
     signal: AbortSignal,
   ): Promise<void> {
-    if (this.isRunning()) {
-      throw new Error(
-        'Cannot schedule new tool calls while other tool calls are actively running (executing or awaiting approval).',
-      );
+    if (this.isRunning() || this.isScheduling) {
+      return new Promise((resolve, reject) => {
+        const abortHandler = () => {
+          // Find and remove the request from the queue
+          const index = this.requestQueue.findIndex(
+            (item) => item.request === request,
+          );
+          if (index > -1) {
+            this.requestQueue.splice(index, 1);
+            reject(new Error('Tool call cancelled while in queue.'));
+          }
+        };
+
+        signal.addEventListener('abort', abortHandler, { once: true });
+
+        this.requestQueue.push({
+          request,
+          signal,
+          resolve: () => {
+            signal.removeEventListener('abort', abortHandler);
+            resolve();
+          },
+          reject: (reason?: Error) => {
+            signal.removeEventListener('abort', abortHandler);
+            reject(reason);
+          },
+        });
+      });
     }
-    const requestsToProcess = Array.isArray(request) ? request : [request];
-    const toolRegistry = await this.toolRegistry;
+    return this._schedule(request, signal);
+  }
 
-    const newToolCalls: ToolCall[] = requestsToProcess.map(
-      (reqInfo): ToolCall => {
-        const toolInstance = toolRegistry.getTool(reqInfo.name);
-        if (!toolInstance) {
-          return {
-            status: 'error',
-            request: reqInfo,
-            response: createErrorResponse(
-              reqInfo,
-              new Error(`Tool "${reqInfo.name}" not found in registry.`),
-              ToolErrorType.TOOL_NOT_REGISTERED,
-            ),
-            durationMs: 0,
-          };
-        }
-
-        const invocationOrError = this.buildInvocation(
-          toolInstance,
-          reqInfo.args,
+  private async _schedule(
+    request: ToolCallRequestInfo | ToolCallRequestInfo[],
+    signal: AbortSignal,
+  ): Promise<void> {
+    this.isScheduling = true;
+    try {
+      if (this.isRunning()) {
+        throw new Error(
+          'Cannot schedule new tool calls while other tool calls are actively running (executing or awaiting approval).',
         );
-        if (invocationOrError instanceof Error) {
+      }
+      const requestsToProcess = Array.isArray(request) ? request : [request];
+      const toolRegistry = await this.toolRegistry;
+
+      const newToolCalls: ToolCall[] = requestsToProcess.map(
+        (reqInfo): ToolCall => {
+          const toolInstance = toolRegistry.getTool(reqInfo.name);
+          if (!toolInstance) {
+            return {
+              status: 'error',
+              request: reqInfo,
+              response: createErrorResponse(
+                reqInfo,
+                new Error(`Tool "${reqInfo.name}" not found in registry.`),
+                ToolErrorType.TOOL_NOT_REGISTERED,
+              ),
+              durationMs: 0,
+            };
+          }
+
+          const invocationOrError = this.buildInvocation(
+            toolInstance,
+            reqInfo.args,
+          );
+          if (invocationOrError instanceof Error) {
+            return {
+              status: 'error',
+              request: reqInfo,
+              tool: toolInstance,
+              response: createErrorResponse(
+                reqInfo,
+                invocationOrError,
+                ToolErrorType.INVALID_TOOL_PARAMS,
+              ),
+              durationMs: 0,
+            };
+          }
+
           return {
-            status: 'error',
+            status: 'validating',
             request: reqInfo,
             tool: toolInstance,
-            response: createErrorResponse(
-              reqInfo,
-              invocationOrError,
-              ToolErrorType.INVALID_TOOL_PARAMS,
-            ),
-            durationMs: 0,
+            invocation: invocationOrError,
+            startTime: Date.now(),
           };
+        },
+      );
+
+      this.toolCalls = this.toolCalls.concat(newToolCalls);
+      this.notifyToolCallsUpdate();
+
+      for (const toolCall of newToolCalls) {
+        if (toolCall.status !== 'validating') {
+          continue;
         }
 
-        return {
-          status: 'validating',
-          request: reqInfo,
-          tool: toolInstance,
-          invocation: invocationOrError,
-          startTime: Date.now(),
-        };
-      },
-    );
+        const { request: reqInfo, invocation } = toolCall;
 
-    this.toolCalls = this.toolCalls.concat(newToolCalls);
-    this.notifyToolCallsUpdate();
-
-    for (const toolCall of newToolCalls) {
-      if (toolCall.status !== 'validating') {
-        continue;
-      }
-
-      const { request: reqInfo, invocation } = toolCall;
-
-      try {
-        if (this.config.getApprovalMode() === ApprovalMode.YOLO) {
-          this.setToolCallOutcome(
-            reqInfo.callId,
-            ToolConfirmationOutcome.ProceedAlways,
-          );
-          this.setStatusInternal(reqInfo.callId, 'scheduled');
-        } else {
-          const confirmationDetails =
-            await invocation.shouldConfirmExecute(signal);
-
-          if (confirmationDetails) {
-            // Allow IDE to resolve confirmation
-            if (
-              confirmationDetails.type === 'edit' &&
-              confirmationDetails.ideConfirmation
-            ) {
-              confirmationDetails.ideConfirmation.then((resolution) => {
-                if (resolution.status === 'accepted') {
-                  this.handleConfirmationResponse(
-                    reqInfo.callId,
-                    confirmationDetails.onConfirm,
-                    ToolConfirmationOutcome.ProceedOnce,
-                    signal,
-                  );
-                } else {
-                  this.handleConfirmationResponse(
-                    reqInfo.callId,
-                    confirmationDetails.onConfirm,
-                    ToolConfirmationOutcome.Cancel,
-                    signal,
-                  );
-                }
-              });
-            }
-
-            const originalOnConfirm = confirmationDetails.onConfirm;
-            const wrappedConfirmationDetails: ToolCallConfirmationDetails = {
-              ...confirmationDetails,
-              onConfirm: (
-                outcome: ToolConfirmationOutcome,
-                payload?: ToolConfirmationPayload,
-              ) =>
-                this.handleConfirmationResponse(
-                  reqInfo.callId,
-                  originalOnConfirm,
-                  outcome,
-                  signal,
-                  payload,
-                ),
-            };
-            this.setStatusInternal(
-              reqInfo.callId,
-              'awaiting_approval',
-              wrappedConfirmationDetails,
-            );
-          } else {
+        try {
+          if (this.config.getApprovalMode() === ApprovalMode.YOLO) {
             this.setToolCallOutcome(
               reqInfo.callId,
               ToolConfirmationOutcome.ProceedAlways,
             );
             this.setStatusInternal(reqInfo.callId, 'scheduled');
+          } else {
+            const confirmationDetails =
+              await invocation.shouldConfirmExecute(signal);
+
+            if (confirmationDetails) {
+              // Allow IDE to resolve confirmation
+              if (
+                confirmationDetails.type === 'edit' &&
+                confirmationDetails.ideConfirmation
+              ) {
+                confirmationDetails.ideConfirmation.then((resolution) => {
+                  if (resolution.status === 'accepted') {
+                    this.handleConfirmationResponse(
+                      reqInfo.callId,
+                      confirmationDetails.onConfirm,
+                      ToolConfirmationOutcome.ProceedOnce,
+                      signal,
+                    );
+                  } else {
+                    this.handleConfirmationResponse(
+                      reqInfo.callId,
+                      confirmationDetails.onConfirm,
+                      ToolConfirmationOutcome.Cancel,
+                      signal,
+                    );
+                  }
+                });
+              }
+
+              const originalOnConfirm = confirmationDetails.onConfirm;
+              const wrappedConfirmationDetails: ToolCallConfirmationDetails = {
+                ...confirmationDetails,
+                onConfirm: (
+                  outcome: ToolConfirmationOutcome,
+                  payload?: ToolConfirmationPayload,
+                ) =>
+                  this.handleConfirmationResponse(
+                    reqInfo.callId,
+                    originalOnConfirm,
+                    outcome,
+                    signal,
+                    payload,
+                  ),
+              };
+              this.setStatusInternal(
+                reqInfo.callId,
+                'awaiting_approval',
+                wrappedConfirmationDetails,
+              );
+            } else {
+              this.setToolCallOutcome(
+                reqInfo.callId,
+                ToolConfirmationOutcome.ProceedAlways,
+              );
+              this.setStatusInternal(reqInfo.callId, 'scheduled');
+            }
           }
+        } catch (error) {
+          this.setStatusInternal(
+            reqInfo.callId,
+            'error',
+            createErrorResponse(
+              reqInfo,
+              error instanceof Error ? error : new Error(String(error)),
+              ToolErrorType.UNHANDLED_EXCEPTION,
+            ),
+          );
         }
-      } catch (error) {
-        this.setStatusInternal(
-          reqInfo.callId,
-          'error',
-          createErrorResponse(
-            reqInfo,
-            error instanceof Error ? error : new Error(String(error)),
-            ToolErrorType.UNHANDLED_EXCEPTION,
-          ),
-        );
       }
+      this.attemptExecutionOfScheduledCalls(signal);
+      void this.checkAndNotifyCompletion();
+    } finally {
+      this.isScheduling = false;
     }
-    this.attemptExecutionOfScheduledCalls(signal);
-    this.checkAndNotifyCompletion();
   }
 
   async handleConfirmationResponse(
@@ -822,7 +874,7 @@ export class CoreToolScheduler {
     }
   }
 
-  private checkAndNotifyCompletion(): void {
+  private async checkAndNotifyCompletion(): Promise<void> {
     const allCallsAreTerminal = this.toolCalls.every(
       (call) =>
         call.status === 'success' ||
@@ -839,9 +891,18 @@ export class CoreToolScheduler {
       }
 
       if (this.onAllToolCallsComplete) {
-        this.onAllToolCallsComplete(completedCalls);
+        this.isFinalizingToolCalls = true;
+        await this.onAllToolCallsComplete(completedCalls);
+        this.isFinalizingToolCalls = false;
       }
       this.notifyToolCallsUpdate();
+      // After completion, process the next item in the queue.
+      if (this.requestQueue.length > 0) {
+        const next = this.requestQueue.shift()!;
+        this._schedule(next.request, next.signal)
+          .then(next.resolve)
+          .catch(next.reject);
+      }
     }
   }
 

From c03ae4377729fb993426e8535cb041f8014f7b3b Mon Sep 17 00:00:00 2001
From: Gal Zahavi <38544478+galz10@users.noreply.github.com>
Date: Fri, 8 Aug 2025 15:11:14 -0700
Subject: [PATCH 070/107] feat: Add option to hide line numbers in code blocks
 (#5857)

Co-authored-by: Jacob Richman <jacob314@gmail.com>
---
 packages/cli/src/config/settings.ts           |  1 +
 packages/cli/src/gemini.tsx                   | 15 +--
 .../cli/src/ui/contexts/SettingsContext.tsx   | 20 ++++
 packages/cli/src/ui/utils/CodeColorizer.tsx   | 25 +++--
 .../cli/src/ui/utils/MarkdownDisplay.test.tsx | 96 ++++++++++++++++---
 packages/cli/src/ui/utils/MarkdownDisplay.tsx |  6 ++
 .../MarkdownDisplay.test.tsx.snap             |  4 +
 7 files changed, 138 insertions(+), 29 deletions(-)
 create mode 100644 packages/cli/src/ui/contexts/SettingsContext.tsx

diff --git a/packages/cli/src/config/settings.ts b/packages/cli/src/config/settings.ts
index a3bd8d47..3c4270d7 100644
--- a/packages/cli/src/config/settings.ts
+++ b/packages/cli/src/config/settings.ts
@@ -141,6 +141,7 @@ export interface Settings {
   loadMemoryFromIncludeDirectories?: boolean;
 
   chatCompression?: ChatCompressionSettings;
+  showLineNumbers?: boolean;
 }
 
 export interface SettingsError {
diff --git a/packages/cli/src/gemini.tsx b/packages/cli/src/gemini.tsx
index 771fcacb..cba18047 100644
--- a/packages/cli/src/gemini.tsx
+++ b/packages/cli/src/gemini.tsx
@@ -41,6 +41,7 @@ import { validateNonInteractiveAuth } from './validateNonInterActiveAuth.js';
 import { checkForUpdates } from './ui/utils/updateCheck.js';
 import { handleAutoUpdate } from './utils/handleAutoUpdate.js';
 import { appEvents, AppEvent } from './utils/events.js';
+import { SettingsContext } from './ui/contexts/SettingsContext.js';
 
 export function validateDnsResolutionOrder(
   order: string | undefined,
@@ -257,12 +258,14 @@ export async function main() {
     setWindowTitle(basename(workspaceRoot), settings);
     const instance = render(
       <React.StrictMode>
-        <AppWrapper
-          config={config}
-          settings={settings}
-          startupWarnings={startupWarnings}
-          version={version}
-        />
+        <SettingsContext.Provider value={settings}>
+          <AppWrapper
+            config={config}
+            settings={settings}
+            startupWarnings={startupWarnings}
+            version={version}
+          />
+        </SettingsContext.Provider>
       </React.StrictMode>,
       { exitOnCtrlC: false },
     );
diff --git a/packages/cli/src/ui/contexts/SettingsContext.tsx b/packages/cli/src/ui/contexts/SettingsContext.tsx
new file mode 100644
index 00000000..130ba66e
--- /dev/null
+++ b/packages/cli/src/ui/contexts/SettingsContext.tsx
@@ -0,0 +1,20 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import React, { useContext } from 'react';
+import { LoadedSettings } from '../../config/settings.js';
+
+export const SettingsContext = React.createContext<LoadedSettings | undefined>(
+  undefined,
+);
+
+export const useSettings = () => {
+  const context = useContext(SettingsContext);
+  if (context === undefined) {
+    throw new Error('useSettings must be used within a SettingsProvider');
+  }
+  return context;
+};
diff --git a/packages/cli/src/ui/utils/CodeColorizer.tsx b/packages/cli/src/ui/utils/CodeColorizer.tsx
index 58b32c7e..b183d556 100644
--- a/packages/cli/src/ui/utils/CodeColorizer.tsx
+++ b/packages/cli/src/ui/utils/CodeColorizer.tsx
@@ -20,6 +20,7 @@ import {
   MaxSizedBox,
   MINIMUM_MAX_HEIGHT,
 } from '../components/shared/MaxSizedBox.js';
+import { LoadedSettings } from '../../config/settings.js';
 
 // Configure theming and parsing utilities.
 const lowlight = createLowlight(common);
@@ -129,9 +130,11 @@ export function colorizeCode(
   availableHeight?: number,
   maxWidth?: number,
   theme?: Theme,
+  settings?: LoadedSettings,
 ): React.ReactNode {
   const codeToHighlight = code.replace(/\n$/, '');
   const activeTheme = theme || themeManager.getActiveTheme();
+  const showLineNumbers = settings?.merged.showLineNumbers ?? true;
 
   try {
     // Render the HAST tree using the adapted theme
@@ -167,12 +170,14 @@ export function colorizeCode(
 
           return (
             <Box key={index}>
-              <Text color={activeTheme.colors.Gray}>
-                {`${String(index + 1 + hiddenLinesCount).padStart(
-                  padWidth,
-                  ' ',
-                )} `}
-              </Text>
+              {showLineNumbers && (
+                <Text color={activeTheme.colors.Gray}>
+                  {`${String(index + 1 + hiddenLinesCount).padStart(
+                    padWidth,
+                    ' ',
+                  )} `}
+                </Text>
+              )}
               <Text color={activeTheme.defaultColor} wrap="wrap">
                 {contentToRender}
               </Text>
@@ -198,9 +203,11 @@ export function colorizeCode(
       >
         {lines.map((line, index) => (
           <Box key={index}>
-            <Text color={activeTheme.defaultColor}>
-              {`${String(index + 1).padStart(padWidth, ' ')} `}
-            </Text>
+            {showLineNumbers && (
+              <Text color={activeTheme.defaultColor}>
+                {`${String(index + 1).padStart(padWidth, ' ')} `}
+              </Text>
+            )}
             <Text color={activeTheme.colors.Gray}>{line}</Text>
           </Box>
         ))}
diff --git a/packages/cli/src/ui/utils/MarkdownDisplay.test.tsx b/packages/cli/src/ui/utils/MarkdownDisplay.test.tsx
index 312c1b5b..dba6bb6d 100644
--- a/packages/cli/src/ui/utils/MarkdownDisplay.test.tsx
+++ b/packages/cli/src/ui/utils/MarkdownDisplay.test.tsx
@@ -7,6 +7,8 @@
 import { render } from 'ink-testing-library';
 import { describe, it, expect, vi, beforeEach } from 'vitest';
 import { MarkdownDisplay } from './MarkdownDisplay.js';
+import { LoadedSettings } from '../../config/settings.js';
+import { SettingsContext } from '../contexts/SettingsContext.js';
 
 describe('<MarkdownDisplay />', () => {
   const baseProps = {
@@ -15,19 +17,32 @@ describe('<MarkdownDisplay />', () => {
     availableTerminalHeight: 40,
   };
 
+  const mockSettings = new LoadedSettings(
+    { path: '', settings: {} },
+    { path: '', settings: {} },
+    { path: '', settings: {} },
+    [],
+  );
+
   beforeEach(() => {
     vi.clearAllMocks();
   });
 
   it('renders nothing for empty text', () => {
-    const { lastFrame } = render(<MarkdownDisplay {...baseProps} text="" />);
+    const { lastFrame } = render(
+      <SettingsContext.Provider value={mockSettings}>
+        <MarkdownDisplay {...baseProps} text="" />
+      </SettingsContext.Provider>,
+    );
     expect(lastFrame()).toMatchSnapshot();
   });
 
   it('renders a simple paragraph', () => {
     const text = 'Hello, world.';
     const { lastFrame } = render(
-      <MarkdownDisplay {...baseProps} text={text} />,
+      <SettingsContext.Provider value={mockSettings}>
+        <MarkdownDisplay {...baseProps} text={text} />
+      </SettingsContext.Provider>,
     );
     expect(lastFrame()).toMatchSnapshot();
   });
@@ -40,7 +55,9 @@ describe('<MarkdownDisplay />', () => {
 #### Header 4
 `;
     const { lastFrame } = render(
-      <MarkdownDisplay {...baseProps} text={text} />,
+      <SettingsContext.Provider value={mockSettings}>
+        <MarkdownDisplay {...baseProps} text={text} />
+      </SettingsContext.Provider>,
     );
     expect(lastFrame()).toMatchSnapshot();
   });
@@ -48,7 +65,9 @@ describe('<MarkdownDisplay />', () => {
   it('renders a fenced code block with a language', () => {
     const text = '```javascript\nconst x = 1;\nconsole.log(x);\n```';
     const { lastFrame } = render(
-      <MarkdownDisplay {...baseProps} text={text} />,
+      <SettingsContext.Provider value={mockSettings}>
+        <MarkdownDisplay {...baseProps} text={text} />
+      </SettingsContext.Provider>,
     );
     expect(lastFrame()).toMatchSnapshot();
   });
@@ -56,7 +75,9 @@ describe('<MarkdownDisplay />', () => {
   it('renders a fenced code block without a language', () => {
     const text = '```\nplain text\n```';
     const { lastFrame } = render(
-      <MarkdownDisplay {...baseProps} text={text} />,
+      <SettingsContext.Provider value={mockSettings}>
+        <MarkdownDisplay {...baseProps} text={text} />
+      </SettingsContext.Provider>,
     );
     expect(lastFrame()).toMatchSnapshot();
   });
@@ -64,7 +85,9 @@ describe('<MarkdownDisplay />', () => {
   it('handles unclosed (pending) code blocks', () => {
     const text = '```typescript\nlet y = 2;';
     const { lastFrame } = render(
-      <MarkdownDisplay {...baseProps} text={text} isPending={true} />,
+      <SettingsContext.Provider value={mockSettings}>
+        <MarkdownDisplay {...baseProps} text={text} isPending={true} />
+      </SettingsContext.Provider>,
     );
     expect(lastFrame()).toMatchSnapshot();
   });
@@ -76,7 +99,9 @@ describe('<MarkdownDisplay />', () => {
 + item C
 `;
     const { lastFrame } = render(
-      <MarkdownDisplay {...baseProps} text={text} />,
+      <SettingsContext.Provider value={mockSettings}>
+        <MarkdownDisplay {...baseProps} text={text} />
+      </SettingsContext.Provider>,
     );
     expect(lastFrame()).toMatchSnapshot();
   });
@@ -88,7 +113,9 @@ describe('<MarkdownDisplay />', () => {
     * Level 3
 `;
     const { lastFrame } = render(
-      <MarkdownDisplay {...baseProps} text={text} />,
+      <SettingsContext.Provider value={mockSettings}>
+        <MarkdownDisplay {...baseProps} text={text} />
+      </SettingsContext.Provider>,
     );
     expect(lastFrame()).toMatchSnapshot();
   });
@@ -99,7 +126,9 @@ describe('<MarkdownDisplay />', () => {
 2. Second item
 `;
     const { lastFrame } = render(
-      <MarkdownDisplay {...baseProps} text={text} />,
+      <SettingsContext.Provider value={mockSettings}>
+        <MarkdownDisplay {...baseProps} text={text} />
+      </SettingsContext.Provider>,
     );
     expect(lastFrame()).toMatchSnapshot();
   });
@@ -113,7 +142,9 @@ World
 Test
 `;
     const { lastFrame } = render(
-      <MarkdownDisplay {...baseProps} text={text} />,
+      <SettingsContext.Provider value={mockSettings}>
+        <MarkdownDisplay {...baseProps} text={text} />
+      </SettingsContext.Provider>,
     );
     expect(lastFrame()).toMatchSnapshot();
   });
@@ -126,7 +157,9 @@ Test
 | Cell 3   | Cell 4   |
 `;
     const { lastFrame } = render(
-      <MarkdownDisplay {...baseProps} text={text} />,
+      <SettingsContext.Provider value={mockSettings}>
+        <MarkdownDisplay {...baseProps} text={text} />
+      </SettingsContext.Provider>,
     );
     expect(lastFrame()).toMatchSnapshot();
   });
@@ -138,7 +171,9 @@ Some text before.
 |---|
 | 1 | 2 |`;
     const { lastFrame } = render(
-      <MarkdownDisplay {...baseProps} text={text} />,
+      <SettingsContext.Provider value={mockSettings}>
+        <MarkdownDisplay {...baseProps} text={text} />
+      </SettingsContext.Provider>,
     );
     expect(lastFrame()).toMatchSnapshot();
   });
@@ -148,7 +183,9 @@ Some text before.
 
 Paragraph 2.`;
     const { lastFrame } = render(
-      <MarkdownDisplay {...baseProps} text={text} />,
+      <SettingsContext.Provider value={mockSettings}>
+        <MarkdownDisplay {...baseProps} text={text} />
+      </SettingsContext.Provider>,
     );
     expect(lastFrame()).toMatchSnapshot();
   });
@@ -169,8 +206,39 @@ some code
 Another paragraph.
 `;
     const { lastFrame } = render(
-      <MarkdownDisplay {...baseProps} text={text} />,
+      <SettingsContext.Provider value={mockSettings}>
+        <MarkdownDisplay {...baseProps} text={text} />
+      </SettingsContext.Provider>,
     );
     expect(lastFrame()).toMatchSnapshot();
   });
+
+  it('hides line numbers in code blocks when showLineNumbers is false', () => {
+    const text = '```javascript\nconst x = 1;\n```';
+    const settings = new LoadedSettings(
+      { path: '', settings: {} },
+      { path: '', settings: { showLineNumbers: false } },
+      { path: '', settings: {} },
+      [],
+    );
+
+    const { lastFrame } = render(
+      <SettingsContext.Provider value={settings}>
+        <MarkdownDisplay {...baseProps} text={text} />
+      </SettingsContext.Provider>,
+    );
+    expect(lastFrame()).toMatchSnapshot();
+    expect(lastFrame()).not.toContain(' 1 ');
+  });
+
+  it('shows line numbers in code blocks by default', () => {
+    const text = '```javascript\nconst x = 1;\n```';
+    const { lastFrame } = render(
+      <SettingsContext.Provider value={mockSettings}>
+        <MarkdownDisplay {...baseProps} text={text} />
+      </SettingsContext.Provider>,
+    );
+    expect(lastFrame()).toMatchSnapshot();
+    expect(lastFrame()).toContain(' 1 ');
+  });
 });
diff --git a/packages/cli/src/ui/utils/MarkdownDisplay.tsx b/packages/cli/src/ui/utils/MarkdownDisplay.tsx
index eb5dc453..7568e1f8 100644
--- a/packages/cli/src/ui/utils/MarkdownDisplay.tsx
+++ b/packages/cli/src/ui/utils/MarkdownDisplay.tsx
@@ -10,6 +10,7 @@ import { Colors } from '../colors.js';
 import { colorizeCode } from './CodeColorizer.js';
 import { TableRenderer } from './TableRenderer.js';
 import { RenderInline } from './InlineMarkdownRenderer.js';
+import { useSettings } from '../contexts/SettingsContext.js';
 
 interface MarkdownDisplayProps {
   text: string;
@@ -298,6 +299,7 @@ const RenderCodeBlockInternal: React.FC<RenderCodeBlockProps> = ({
   availableTerminalHeight,
   terminalWidth,
 }) => {
+  const settings = useSettings();
   const MIN_LINES_FOR_MESSAGE = 1; // Minimum lines to show before the "generating more" message
   const RESERVED_LINES = 2; // Lines reserved for the message itself and potential padding
 
@@ -322,6 +324,8 @@ const RenderCodeBlockInternal: React.FC<RenderCodeBlockProps> = ({
         lang,
         availableTerminalHeight,
         terminalWidth - CODE_BLOCK_PREFIX_PADDING,
+        undefined,
+        settings,
       );
       return (
         <Box paddingLeft={CODE_BLOCK_PREFIX_PADDING} flexDirection="column">
@@ -338,6 +342,8 @@ const RenderCodeBlockInternal: React.FC<RenderCodeBlockProps> = ({
     lang,
     availableTerminalHeight,
     terminalWidth - CODE_BLOCK_PREFIX_PADDING,
+    undefined,
+    settings,
   );
 
   return (
diff --git a/packages/cli/src/ui/utils/__snapshots__/MarkdownDisplay.test.tsx.snap b/packages/cli/src/ui/utils/__snapshots__/MarkdownDisplay.test.tsx.snap
index 66436bbd..223c293b 100644
--- a/packages/cli/src/ui/utils/__snapshots__/MarkdownDisplay.test.tsx.snap
+++ b/packages/cli/src/ui/utils/__snapshots__/MarkdownDisplay.test.tsx.snap
@@ -23,6 +23,8 @@ exports[`<MarkdownDisplay /> > handles a table at the end of the input 1`] = `
 
 exports[`<MarkdownDisplay /> > handles unclosed (pending) code blocks 1`] = `" 1 let y = 2;"`;
 
+exports[`<MarkdownDisplay /> > hides line numbers in code blocks when showLineNumbers is false 1`] = `" const x = 1;"`;
+
 exports[`<MarkdownDisplay /> > inserts a single space between paragraphs 1`] = `
 "Paragraph 1.
 
@@ -87,3 +89,5 @@ exports[`<MarkdownDisplay /> > renders unordered lists with different markers 1`
  + item C
 "
 `;
+
+exports[`<MarkdownDisplay /> > shows line numbers in code blocks by default 1`] = `" 1 const x = 1;"`;

From f35921a77171d011d244cba1b2da0531f9749332 Mon Sep 17 00:00:00 2001
From: Jacob MacDonald <jakemac@google.com>
Date: Fri, 8 Aug 2025 16:29:06 -0700
Subject: [PATCH 071/107] Add MCP Roots support (#5856)

Co-authored-by: Jacob Richman <jacob314@gmail.com>
---
 packages/core/src/tools/mcp-client.test.ts    | 57 ++++++++++++++++++-
 packages/core/src/tools/mcp-client.ts         | 26 +++++++++
 packages/core/src/tools/tool-registry.test.ts |  2 +
 packages/core/src/tools/tool-registry.ts      |  3 +
 4 files changed, 87 insertions(+), 1 deletion(-)

diff --git a/packages/core/src/tools/mcp-client.test.ts b/packages/core/src/tools/mcp-client.test.ts
index 1ccba76a..d37c6eae 100644
--- a/packages/core/src/tools/mcp-client.test.ts
+++ b/packages/core/src/tools/mcp-client.test.ts
@@ -13,6 +13,7 @@ import {
   discoverTools,
   discoverPrompts,
   hasValidTypes,
+  connectToMcpServer,
 } from './mcp-client.js';
 import { SSEClientTransport } from '@modelcontextprotocol/sdk/client/sse.js';
 import * as SdkClientStdioLib from '@modelcontextprotocol/sdk/client/stdio.js';
@@ -23,6 +24,8 @@ import { AuthProviderType } from '../config/config.js';
 import { PromptRegistry } from '../prompts/prompt-registry.js';
 
 import { DiscoveredMCPTool } from './mcp-tool.js';
+import { WorkspaceContext } from '../utils/workspaceContext.js';
+import { pathToFileURL } from 'node:url';
 
 vi.mock('@modelcontextprotocol/sdk/client/stdio.js');
 vi.mock('@modelcontextprotocol/sdk/client/index.js');
@@ -276,6 +279,56 @@ describe('mcp-client', () => {
     });
   });
 
+  describe('connectToMcpServer', () => {
+    it('should register a roots/list handler', async () => {
+      const mockedClient = {
+        registerCapabilities: vi.fn(),
+        setRequestHandler: vi.fn(),
+        callTool: vi.fn(),
+        connect: vi.fn(),
+      };
+      vi.mocked(ClientLib.Client).mockReturnValue(
+        mockedClient as unknown as ClientLib.Client,
+      );
+      vi.spyOn(SdkClientStdioLib, 'StdioClientTransport').mockReturnValue(
+        {} as SdkClientStdioLib.StdioClientTransport,
+      );
+      const mockWorkspaceContext = {
+        getDirectories: vi
+          .fn()
+          .mockReturnValue(['/test/dir', '/another/project']),
+      } as unknown as WorkspaceContext;
+
+      await connectToMcpServer(
+        'test-server',
+        {
+          command: 'test-command',
+        },
+        false,
+        mockWorkspaceContext,
+      );
+
+      expect(mockedClient.registerCapabilities).toHaveBeenCalledWith({
+        roots: {},
+      });
+      expect(mockedClient.setRequestHandler).toHaveBeenCalledOnce();
+      const handler = mockedClient.setRequestHandler.mock.calls[0][1];
+      const roots = await handler();
+      expect(roots).toEqual({
+        roots: [
+          {
+            uri: pathToFileURL('/test/dir').toString(),
+            name: 'dir',
+          },
+          {
+            uri: pathToFileURL('/another/project').toString(),
+            name: 'project',
+          },
+        ],
+      });
+    });
+  });
+
   describe('discoverPrompts', () => {
     const mockedPromptRegistry = {
       registerPrompt: vi.fn(),
@@ -486,7 +539,9 @@ describe('mcp-client', () => {
     });
 
     it('should connect via command', async () => {
-      const mockedTransport = vi.mocked(SdkClientStdioLib.StdioClientTransport);
+      const mockedTransport = vi
+        .spyOn(SdkClientStdioLib, 'StdioClientTransport')
+        .mockReturnValue({} as SdkClientStdioLib.StdioClientTransport);
 
       await createTransport(
         'test-server',
diff --git a/packages/core/src/tools/mcp-client.ts b/packages/core/src/tools/mcp-client.ts
index 9a35b84e..83bc4024 100644
--- a/packages/core/src/tools/mcp-client.ts
+++ b/packages/core/src/tools/mcp-client.ts
@@ -20,6 +20,7 @@ import {
   ListPromptsResultSchema,
   GetPromptResult,
   GetPromptResultSchema,
+  ListRootsRequestSchema,
 } from '@modelcontextprotocol/sdk/types.js';
 import { parse } from 'shell-quote';
 import { AuthProviderType, MCPServerConfig } from '../config/config.js';
@@ -33,6 +34,9 @@ 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 { WorkspaceContext } from '../utils/workspaceContext.js';
 
 export const MCP_DEFAULT_TIMEOUT_MSEC = 10 * 60 * 1000; // default to 10 minutes
 
@@ -306,6 +310,7 @@ export async function discoverMcpTools(
   toolRegistry: ToolRegistry,
   promptRegistry: PromptRegistry,
   debugMode: boolean,
+  workspaceContext: WorkspaceContext,
 ): Promise<void> {
   mcpDiscoveryState = MCPDiscoveryState.IN_PROGRESS;
   try {
@@ -319,6 +324,7 @@ export async function discoverMcpTools(
           toolRegistry,
           promptRegistry,
           debugMode,
+          workspaceContext,
         ),
     );
     await Promise.all(discoveryPromises);
@@ -363,6 +369,7 @@ export async function connectAndDiscover(
   toolRegistry: ToolRegistry,
   promptRegistry: PromptRegistry,
   debugMode: boolean,
+  workspaceContext: WorkspaceContext,
 ): Promise<void> {
   updateMCPServerStatus(mcpServerName, MCPServerStatus.CONNECTING);
 
@@ -372,6 +379,7 @@ export async function connectAndDiscover(
       mcpServerName,
       mcpServerConfig,
       debugMode,
+      workspaceContext,
     );
 
     mcpClient.onerror = (error) => {
@@ -655,12 +663,30 @@ export async function connectToMcpServer(
   mcpServerName: string,
   mcpServerConfig: MCPServerConfig,
   debugMode: boolean,
+  workspaceContext: WorkspaceContext,
 ): Promise<Client> {
   const mcpClient = new Client({
     name: 'gemini-cli-mcp-client',
     version: '0.0.1',
   });
 
+  mcpClient.registerCapabilities({
+    roots: {},
+  });
+
+  mcpClient.setRequestHandler(ListRootsRequestSchema, async () => {
+    const roots = [];
+    for (const dir of workspaceContext.getDirectories()) {
+      roots.push({
+        uri: pathToFileURL(dir).toString(),
+        name: basename(dir),
+      });
+    }
+    return {
+      roots,
+    };
+  });
+
   // 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) {
diff --git a/packages/core/src/tools/tool-registry.test.ts b/packages/core/src/tools/tool-registry.test.ts
index e7c71e14..d8e536b7 100644
--- a/packages/core/src/tools/tool-registry.test.ts
+++ b/packages/core/src/tools/tool-registry.test.ts
@@ -336,6 +336,7 @@ describe('ToolRegistry', () => {
         toolRegistry,
         config.getPromptRegistry(),
         false,
+        expect.any(Object),
       );
     });
 
@@ -359,6 +360,7 @@ describe('ToolRegistry', () => {
         toolRegistry,
         config.getPromptRegistry(),
         false,
+        expect.any(Object),
       );
     });
   });
diff --git a/packages/core/src/tools/tool-registry.ts b/packages/core/src/tools/tool-registry.ts
index c77fab8c..70226052 100644
--- a/packages/core/src/tools/tool-registry.ts
+++ b/packages/core/src/tools/tool-registry.ts
@@ -178,6 +178,7 @@ export class ToolRegistry {
       this,
       this.config.getPromptRegistry(),
       this.config.getDebugMode(),
+      this.config.getWorkspaceContext(),
     );
   }
 
@@ -199,6 +200,7 @@ export class ToolRegistry {
       this,
       this.config.getPromptRegistry(),
       this.config.getDebugMode(),
+      this.config.getWorkspaceContext(),
     );
   }
 
@@ -225,6 +227,7 @@ export class ToolRegistry {
         this,
         this.config.getPromptRegistry(),
         this.config.getDebugMode(),
+        this.config.getWorkspaceContext(),
       );
     }
   }

From c184ec32247bbbffb41ae96316a18b3a24257f0e Mon Sep 17 00:00:00 2001
From: "N. Taylor Mullen" <ntaylormullen@google.com>
Date: Fri, 8 Aug 2025 17:26:43 -0700
Subject: [PATCH 072/107] chore(release): v0.1.18 (#5864)

---
 package-lock.json                | 10 +++++-----
 package.json                     |  4 ++--
 packages/cli/package.json        |  4 ++--
 packages/core/package.json       |  2 +-
 packages/test-utils/package.json |  2 +-
 5 files changed, 11 insertions(+), 11 deletions(-)

diff --git a/package-lock.json b/package-lock.json
index 0ee930b4..9ee6b751 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@google/gemini-cli",
-  "version": "0.1.17",
+  "version": "0.1.18",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@google/gemini-cli",
-      "version": "0.1.17",
+      "version": "0.1.18",
       "workspaces": [
         "packages/*"
       ],
@@ -11685,7 +11685,7 @@
     },
     "packages/cli": {
       "name": "@google/gemini-cli",
-      "version": "0.1.17",
+      "version": "0.1.18",
       "dependencies": {
         "@google/gemini-cli-core": "file:../core",
         "@google/genai": "1.9.0",
@@ -11889,7 +11889,7 @@
     },
     "packages/core": {
       "name": "@google/gemini-cli-core",
-      "version": "0.1.17",
+      "version": "0.1.18",
       "dependencies": {
         "@google/genai": "1.9.0",
         "@modelcontextprotocol/sdk": "^1.11.0",
@@ -12016,7 +12016,7 @@
     },
     "packages/test-utils": {
       "name": "@google/gemini-cli-test-utils",
-      "version": "0.1.0",
+      "version": "0.1.18",
       "license": "Apache-2.0",
       "devDependencies": {
         "typescript": "^5.3.3"
diff --git a/package.json b/package.json
index d848a81b..281f59fe 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@google/gemini-cli",
-  "version": "0.1.17",
+  "version": "0.1.18",
   "engines": {
     "node": ">=20.0.0"
   },
@@ -14,7 +14,7 @@
     "url": "git+https://github.com/google-gemini/gemini-cli.git"
   },
   "config": {
-    "sandboxImageUri": "us-docker.pkg.dev/gemini-code-dev/gemini-cli/sandbox:0.1.17"
+    "sandboxImageUri": "us-docker.pkg.dev/gemini-code-dev/gemini-cli/sandbox:0.1.18"
   },
   "scripts": {
     "start": "node scripts/start.js",
diff --git a/packages/cli/package.json b/packages/cli/package.json
index 59d1cbf2..582705f7 100644
--- a/packages/cli/package.json
+++ b/packages/cli/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@google/gemini-cli",
-  "version": "0.1.17",
+  "version": "0.1.18",
   "description": "Gemini CLI",
   "repository": {
     "type": "git",
@@ -25,7 +25,7 @@
     "dist"
   ],
   "config": {
-    "sandboxImageUri": "us-docker.pkg.dev/gemini-code-dev/gemini-cli/sandbox:0.1.17"
+    "sandboxImageUri": "us-docker.pkg.dev/gemini-code-dev/gemini-cli/sandbox:0.1.18"
   },
   "dependencies": {
     "@google/gemini-cli-core": "file:../core",
diff --git a/packages/core/package.json b/packages/core/package.json
index b82feb7f..e78a33cf 100644
--- a/packages/core/package.json
+++ b/packages/core/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@google/gemini-cli-core",
-  "version": "0.1.17",
+  "version": "0.1.18",
   "description": "Gemini CLI Core",
   "repository": {
     "type": "git",
diff --git a/packages/test-utils/package.json b/packages/test-utils/package.json
index 846a2ec0..fe401c37 100644
--- a/packages/test-utils/package.json
+++ b/packages/test-utils/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@google/gemini-cli-test-utils",
-  "version": "0.1.0",
+  "version": "0.1.18",
   "private": true,
   "main": "src/index.ts",
   "license": "Apache-2.0",

From 191cc01bf5833a4c7636f8fc4d9b4c5066982822 Mon Sep 17 00:00:00 2001
From: Brian de Alwis <bsd@acm.org>
Date: Fri, 8 Aug 2025 23:05:30 -0400
Subject: [PATCH 073/107] fix(core): restrict  oauth_creds.json file
 permissions (#5245)

Co-authored-by: cornmander <shikhman@google.com>
---
 packages/core/src/code_assist/oauth2.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/packages/core/src/code_assist/oauth2.ts b/packages/core/src/code_assist/oauth2.ts
index f1046416..dc1ec490 100644
--- a/packages/core/src/code_assist/oauth2.ts
+++ b/packages/core/src/code_assist/oauth2.ts
@@ -366,7 +366,7 @@ async function cacheCredentials(credentials: Credentials) {
   await fs.mkdir(path.dirname(filePath), { recursive: true });
 
   const credString = JSON.stringify(credentials, null, 2);
-  await fs.writeFile(filePath, credString);
+  await fs.writeFile(filePath, credString, { mode: 0o600 });
 }
 
 function getCachedCredentialPath(): string {

From 6487cc16895976ef6c983f8beca08a64addb6688 Mon Sep 17 00:00:00 2001
From: Hiroaki Mitsuyoshi <131056197+flowernotfound@users.noreply.github.com>
Date: Sat, 9 Aug 2025 15:59:22 +0900
Subject: [PATCH 074/107] feat(chat): Add overwrite confirmation dialog to
 `/chat save` (#5686)

Co-authored-by: Jacob Richman <jacob314@gmail.com>
---
 packages/cli/src/ui/App.tsx                   | 17 +++++++
 .../cli/src/ui/commands/chatCommand.test.ts   | 50 ++++++++++++++++++-
 packages/cli/src/ui/commands/chatCommand.ts   | 26 +++++++++-
 packages/cli/src/ui/commands/types.ts         | 16 +++++-
 .../cli/src/ui/hooks/slashCommandProcessor.ts | 39 +++++++++++++++
 packages/core/src/core/logger.test.ts         | 46 +++++++++++++++++
 packages/core/src/core/logger.ts              | 23 +++++++++
 7 files changed, 214 insertions(+), 3 deletions(-)

diff --git a/packages/cli/src/ui/App.tsx b/packages/cli/src/ui/App.tsx
index 9f18fe55..e3c77ad0 100644
--- a/packages/cli/src/ui/App.tsx
+++ b/packages/cli/src/ui/App.tsx
@@ -39,6 +39,7 @@ import { AuthInProgress } from './components/AuthInProgress.js';
 import { EditorSettingsDialog } from './components/EditorSettingsDialog.js';
 import { FolderTrustDialog } from './components/FolderTrustDialog.js';
 import { ShellConfirmationDialog } from './components/ShellConfirmationDialog.js';
+import { RadioButtonSelect } from './components/shared/RadioButtonSelect.js';
 import { Colors } from './colors.js';
 import { loadHierarchicalGeminiMemory } from '../config/config.js';
 import { LoadedSettings, SettingScope } from '../config/settings.js';
@@ -488,6 +489,7 @@ const App = ({ config, settings, startupWarnings = [], version }: AppProps) => {
     pendingHistoryItems: pendingSlashCommandHistoryItems,
     commandContext,
     shellConfirmationRequest,
+    confirmationRequest,
   } = useSlashCommandProcessor(
     config,
     settings,
@@ -912,6 +914,21 @@ const App = ({ config, settings, startupWarnings = [], version }: AppProps) => {
             <FolderTrustDialog onSelect={handleFolderTrustSelect} />
           ) : shellConfirmationRequest ? (
             <ShellConfirmationDialog request={shellConfirmationRequest} />
+          ) : confirmationRequest ? (
+            <Box flexDirection="column">
+              {confirmationRequest.prompt}
+              <Box paddingY={1}>
+                <RadioButtonSelect
+                  items={[
+                    { label: 'Yes', value: true },
+                    { label: 'No', value: false },
+                  ]}
+                  onSelect={(value: boolean) => {
+                    confirmationRequest.onConfirm(value);
+                  }}
+                />
+              </Box>
+            </Box>
           ) : isThemeDialogOpen ? (
             <Box flexDirection="column">
               {themeError && (
diff --git a/packages/cli/src/ui/commands/chatCommand.test.ts b/packages/cli/src/ui/commands/chatCommand.test.ts
index aad0897c..ccdfd4b2 100644
--- a/packages/cli/src/ui/commands/chatCommand.test.ts
+++ b/packages/cli/src/ui/commands/chatCommand.test.ts
@@ -168,8 +168,12 @@ describe('chatCommand', () => {
   describe('save subcommand', () => {
     let saveCommand: SlashCommand;
     const tag = 'my-tag';
+    let mockCheckpointExists: ReturnType<typeof vi.fn>;
+
     beforeEach(() => {
       saveCommand = getSubCommand('save');
+      mockCheckpointExists = vi.fn().mockResolvedValue(false);
+      mockContext.services.logger.checkpointExists = mockCheckpointExists;
     });
 
     it('should return an error if tag is missing', async () => {
@@ -191,7 +195,7 @@ describe('chatCommand', () => {
       });
     });
 
-    it('should save the conversation', async () => {
+    it('should save the conversation if checkpoint does not exist', async () => {
       const history: HistoryItemWithoutId[] = [
         {
           type: 'user',
@@ -199,8 +203,52 @@ describe('chatCommand', () => {
         },
       ];
       mockGetHistory.mockReturnValue(history);
+      mockCheckpointExists.mockResolvedValue(false);
+
       const result = await saveCommand?.action?.(mockContext, tag);
 
+      expect(mockCheckpointExists).toHaveBeenCalledWith(tag);
+      expect(mockSaveCheckpoint).toHaveBeenCalledWith(history, tag);
+      expect(result).toEqual({
+        type: 'message',
+        messageType: 'info',
+        content: `Conversation checkpoint saved with tag: ${tag}.`,
+      });
+    });
+
+    it('should return confirm_action if checkpoint already exists', async () => {
+      mockCheckpointExists.mockResolvedValue(true);
+      mockContext.invocation = {
+        raw: `/chat save ${tag}`,
+        name: 'save',
+        args: tag,
+      };
+
+      const result = await saveCommand?.action?.(mockContext, tag);
+
+      expect(mockCheckpointExists).toHaveBeenCalledWith(tag);
+      expect(mockSaveCheckpoint).not.toHaveBeenCalled();
+      expect(result).toMatchObject({
+        type: 'confirm_action',
+        originalInvocation: { raw: `/chat save ${tag}` },
+      });
+      // Check that prompt is a React element
+      expect(result).toHaveProperty('prompt');
+    });
+
+    it('should save the conversation if overwrite is confirmed', async () => {
+      const history: HistoryItemWithoutId[] = [
+        {
+          type: 'user',
+          text: 'hello',
+        },
+      ];
+      mockGetHistory.mockReturnValue(history);
+      mockContext.overwriteConfirmed = true;
+
+      const result = await saveCommand?.action?.(mockContext, tag);
+
+      expect(mockCheckpointExists).not.toHaveBeenCalled(); // Should skip existence check
       expect(mockSaveCheckpoint).toHaveBeenCalledWith(history, tag);
       expect(result).toEqual({
         type: 'message',
diff --git a/packages/cli/src/ui/commands/chatCommand.ts b/packages/cli/src/ui/commands/chatCommand.ts
index a5fa13da..56eebe1a 100644
--- a/packages/cli/src/ui/commands/chatCommand.ts
+++ b/packages/cli/src/ui/commands/chatCommand.ts
@@ -5,11 +5,15 @@
  */
 
 import * as fsPromises from 'fs/promises';
+import React from 'react';
+import { Text } from 'ink';
+import { Colors } from '../colors.js';
 import {
   CommandContext,
   SlashCommand,
   MessageActionReturn,
   CommandKind,
+  SlashCommandActionReturn,
 } from './types.js';
 import path from 'path';
 import { HistoryItemWithoutId, MessageType } from '../types.js';
@@ -96,7 +100,7 @@ const saveCommand: SlashCommand = {
   description:
     'Save the current conversation as a checkpoint. Usage: /chat save <tag>',
   kind: CommandKind.BUILT_IN,
-  action: async (context, args): Promise<MessageActionReturn> => {
+  action: async (context, args): Promise<SlashCommandActionReturn | void> => {
     const tag = args.trim();
     if (!tag) {
       return {
@@ -108,6 +112,26 @@ const saveCommand: SlashCommand = {
 
     const { logger, config } = context.services;
     await logger.initialize();
+
+    if (!context.overwriteConfirmed) {
+      const exists = await logger.checkpointExists(tag);
+      if (exists) {
+        return {
+          type: 'confirm_action',
+          prompt: React.createElement(
+            Text,
+            null,
+            'A checkpoint with the tag ',
+            React.createElement(Text, { color: Colors.AccentPurple }, tag),
+            ' already exists. Do you want to overwrite it?',
+          ),
+          originalInvocation: {
+            raw: context.invocation?.raw || `/chat save ${tag}`,
+          },
+        };
+      }
+    }
+
     const chat = await config?.getGeminiClient()?.getChat();
     if (!chat) {
       return {
diff --git a/packages/cli/src/ui/commands/types.ts b/packages/cli/src/ui/commands/types.ts
index 09d79e9d..529f4eb8 100644
--- a/packages/cli/src/ui/commands/types.ts
+++ b/packages/cli/src/ui/commands/types.ts
@@ -4,6 +4,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
+import { type ReactNode } from 'react';
 import { Content } from '@google/genai';
 import { HistoryItemWithoutId } from '../types.js';
 import { Config, GitService, Logger } from '@google/gemini-cli-core';
@@ -67,6 +68,8 @@ export interface CommandContext {
     /** A transient list of shell commands the user has approved for this session. */
     sessionShellAllowlist: Set<string>;
   };
+  // Flag to indicate if an overwrite has been confirmed
+  overwriteConfirmed?: boolean;
 }
 
 /**
@@ -135,6 +138,16 @@ export interface ConfirmShellCommandsActionReturn {
   };
 }
 
+export interface ConfirmActionReturn {
+  type: 'confirm_action';
+  /** The React node to display as the confirmation prompt. */
+  prompt: ReactNode;
+  /** The original invocation context to be re-run after confirmation. */
+  originalInvocation: {
+    raw: string;
+  };
+}
+
 export type SlashCommandActionReturn =
   | ToolActionReturn
   | MessageActionReturn
@@ -142,7 +155,8 @@ export type SlashCommandActionReturn =
   | OpenDialogActionReturn
   | LoadHistoryActionReturn
   | SubmitPromptActionReturn
-  | ConfirmShellCommandsActionReturn;
+  | ConfirmShellCommandsActionReturn
+  | ConfirmActionReturn;
 
 export enum CommandKind {
   BUILT_IN = 'built-in',
diff --git a/packages/cli/src/ui/hooks/slashCommandProcessor.ts b/packages/cli/src/ui/hooks/slashCommandProcessor.ts
index 9f4bbf90..ca08abb1 100644
--- a/packages/cli/src/ui/hooks/slashCommandProcessor.ts
+++ b/packages/cli/src/ui/hooks/slashCommandProcessor.ts
@@ -64,6 +64,11 @@ export const useSlashCommandProcessor = (
         approvedCommands?: string[],
       ) => void;
     }>(null);
+  const [confirmationRequest, setConfirmationRequest] = useState<null | {
+    prompt: React.ReactNode;
+    onConfirm: (confirmed: boolean) => void;
+  }>(null);
+
   const [sessionShellAllowlist, setSessionShellAllowlist] = useState(
     new Set<string>(),
   );
@@ -220,6 +225,7 @@ export const useSlashCommandProcessor = (
     async (
       rawQuery: PartListUnion,
       oneTimeShellAllowlist?: Set<string>,
+      overwriteConfirmed?: boolean,
     ): Promise<SlashCommandProcessorResult | false> => {
       setIsProcessing(true);
       try {
@@ -299,6 +305,7 @@ export const useSlashCommandProcessor = (
                 name: commandToExecute.name,
                 args,
               },
+              overwriteConfirmed,
             };
 
             // If a one-time list is provided for a "Proceed" action, temporarily
@@ -422,6 +429,36 @@ export const useSlashCommandProcessor = (
                     new Set(approvedCommands),
                   );
                 }
+                case 'confirm_action': {
+                  const { confirmed } = await new Promise<{
+                    confirmed: boolean;
+                  }>((resolve) => {
+                    setConfirmationRequest({
+                      prompt: result.prompt,
+                      onConfirm: (resolvedConfirmed) => {
+                        setConfirmationRequest(null);
+                        resolve({ confirmed: resolvedConfirmed });
+                      },
+                    });
+                  });
+
+                  if (!confirmed) {
+                    addItem(
+                      {
+                        type: MessageType.INFO,
+                        text: 'Operation cancelled.',
+                      },
+                      Date.now(),
+                    );
+                    return { type: 'handled' };
+                  }
+
+                  return await handleSlashCommand(
+                    result.originalInvocation.raw,
+                    undefined,
+                    true,
+                  );
+                }
                 default: {
                   const unhandled: never = result;
                   throw new Error(
@@ -478,6 +515,7 @@ export const useSlashCommandProcessor = (
       setShellConfirmationRequest,
       setSessionShellAllowlist,
       setIsProcessing,
+      setConfirmationRequest,
     ],
   );
 
@@ -487,5 +525,6 @@ export const useSlashCommandProcessor = (
     pendingHistoryItems,
     commandContext,
     shellConfirmationRequest,
+    confirmationRequest,
   };
 };
diff --git a/packages/core/src/core/logger.test.ts b/packages/core/src/core/logger.test.ts
index 3f243b52..d032e2d4 100644
--- a/packages/core/src/core/logger.test.ts
+++ b/packages/core/src/core/logger.test.ts
@@ -565,6 +565,52 @@ describe('Logger', () => {
     });
   });
 
+  describe('checkpointExists', () => {
+    const tag = 'exists-test';
+    let taggedFilePath: string;
+
+    beforeEach(() => {
+      taggedFilePath = path.join(TEST_GEMINI_DIR, `checkpoint-${tag}.json`);
+    });
+
+    it('should return true if the checkpoint file exists', async () => {
+      await fs.writeFile(taggedFilePath, '{}');
+      const exists = await logger.checkpointExists(tag);
+      expect(exists).toBe(true);
+    });
+
+    it('should return false if the checkpoint file does not exist', async () => {
+      const exists = await logger.checkpointExists('non-existent-tag');
+      expect(exists).toBe(false);
+    });
+
+    it('should throw an error if logger is not initialized', async () => {
+      const uninitializedLogger = new Logger(testSessionId);
+      uninitializedLogger.close();
+
+      await expect(uninitializedLogger.checkpointExists(tag)).rejects.toThrow(
+        'Logger not initialized. Cannot check for checkpoint existence.',
+      );
+    });
+
+    it('should re-throw an error if fs.access fails for reasons other than not existing', async () => {
+      vi.spyOn(fs, 'access').mockRejectedValueOnce(
+        new Error('EACCES: permission denied'),
+      );
+      const consoleErrorSpy = vi
+        .spyOn(console, 'error')
+        .mockImplementation(() => {});
+
+      await expect(logger.checkpointExists(tag)).rejects.toThrow(
+        'EACCES: permission denied',
+      );
+      expect(consoleErrorSpy).toHaveBeenCalledWith(
+        `Failed to check checkpoint existence for ${taggedFilePath}:`,
+        expect.any(Error),
+      );
+    });
+  });
+
   describe('close', () => {
     it('should reset logger state', async () => {
       await logger.logMessage(MessageSenderType.USER, 'A message');
diff --git a/packages/core/src/core/logger.ts b/packages/core/src/core/logger.ts
index 9f4622e7..f4857f47 100644
--- a/packages/core/src/core/logger.ts
+++ b/packages/core/src/core/logger.ts
@@ -310,6 +310,29 @@ export class Logger {
     }
   }
 
+  async checkpointExists(tag: string): Promise<boolean> {
+    if (!this.initialized) {
+      throw new Error(
+        'Logger not initialized. Cannot check for checkpoint existence.',
+      );
+    }
+    const filePath = this._checkpointPath(tag);
+    try {
+      await fs.access(filePath);
+      return true;
+    } catch (error) {
+      const nodeError = error as NodeJS.ErrnoException;
+      if (nodeError.code === 'ENOENT') {
+        return false;
+      }
+      console.error(
+        `Failed to check checkpoint existence for ${filePath}:`,
+        error,
+      );
+      throw error;
+    }
+  }
+
   close(): void {
     this.initialized = false;
     this.logFilePath = undefined;

From b8084ba8158b89facd49fd78a51abb80b1db54da Mon Sep 17 00:00:00 2001
From: Lee Won Jun <dldnjs1013@nate.com>
Date: Sat, 9 Aug 2025 16:03:17 +0900
Subject: [PATCH 075/107] Centralize Key Binding Logic and Refactor (Reopen)
 (#5356)

Co-authored-by: Lee-WonJun <10369528+Lee-WonJun@users.noreply.github.com>
---
 packages/cli/src/config/keyBindings.test.ts   |  62 ++++
 packages/cli/src/config/keyBindings.ts        | 180 ++++++++++
 packages/cli/src/ui/App.tsx                   | 107 +++---
 .../cli/src/ui/components/InputPrompt.tsx     |  68 ++--
 packages/cli/src/ui/keyMatchers.test.ts       | 338 ++++++++++++++++++
 packages/cli/src/ui/keyMatchers.ts            | 105 ++++++
 6 files changed, 788 insertions(+), 72 deletions(-)
 create mode 100644 packages/cli/src/config/keyBindings.test.ts
 create mode 100644 packages/cli/src/config/keyBindings.ts
 create mode 100644 packages/cli/src/ui/keyMatchers.test.ts
 create mode 100644 packages/cli/src/ui/keyMatchers.ts

diff --git a/packages/cli/src/config/keyBindings.test.ts b/packages/cli/src/config/keyBindings.test.ts
new file mode 100644
index 00000000..2e89e421
--- /dev/null
+++ b/packages/cli/src/config/keyBindings.test.ts
@@ -0,0 +1,62 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { describe, it, expect } from 'vitest';
+import {
+  Command,
+  KeyBindingConfig,
+  defaultKeyBindings,
+} from './keyBindings.js';
+
+describe('keyBindings config', () => {
+  describe('defaultKeyBindings', () => {
+    it('should have bindings for all commands', () => {
+      const commands = Object.values(Command);
+
+      for (const command of commands) {
+        expect(defaultKeyBindings[command]).toBeDefined();
+        expect(Array.isArray(defaultKeyBindings[command])).toBe(true);
+      }
+    });
+
+    it('should have valid key binding structures', () => {
+      for (const [_, bindings] of Object.entries(defaultKeyBindings)) {
+        for (const binding of bindings) {
+          // Each binding should have either key or sequence, but not both
+          const hasKey = binding.key !== undefined;
+          const hasSequence = binding.sequence !== undefined;
+
+          expect(hasKey || hasSequence).toBe(true);
+          expect(hasKey && hasSequence).toBe(false);
+
+          // Modifier properties should be boolean or undefined
+          if (binding.ctrl !== undefined) {
+            expect(typeof binding.ctrl).toBe('boolean');
+          }
+          if (binding.shift !== undefined) {
+            expect(typeof binding.shift).toBe('boolean');
+          }
+          if (binding.command !== undefined) {
+            expect(typeof binding.command).toBe('boolean');
+          }
+          if (binding.paste !== undefined) {
+            expect(typeof binding.paste).toBe('boolean');
+          }
+        }
+      }
+    });
+
+    it('should export all required types', () => {
+      // Basic type checks
+      expect(typeof Command.HOME).toBe('string');
+      expect(typeof Command.END).toBe('string');
+
+      // Config should be readonly
+      const config: KeyBindingConfig = defaultKeyBindings;
+      expect(config[Command.HOME]).toBeDefined();
+    });
+  });
+});
diff --git a/packages/cli/src/config/keyBindings.ts b/packages/cli/src/config/keyBindings.ts
new file mode 100644
index 00000000..f6ba52e2
--- /dev/null
+++ b/packages/cli/src/config/keyBindings.ts
@@ -0,0 +1,180 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Command enum for all available keyboard shortcuts
+ */
+export enum Command {
+  // Basic bindings
+  RETURN = 'return',
+  ESCAPE = 'escape',
+
+  // Cursor movement
+  HOME = 'home',
+  END = 'end',
+
+  // Text deletion
+  KILL_LINE_RIGHT = 'killLineRight',
+  KILL_LINE_LEFT = 'killLineLeft',
+  CLEAR_INPUT = 'clearInput',
+
+  // Screen control
+  CLEAR_SCREEN = 'clearScreen',
+
+  // History navigation
+  HISTORY_UP = 'historyUp',
+  HISTORY_DOWN = 'historyDown',
+  NAVIGATION_UP = 'navigationUp',
+  NAVIGATION_DOWN = 'navigationDown',
+
+  // Auto-completion
+  ACCEPT_SUGGESTION = 'acceptSuggestion',
+
+  // Text input
+  SUBMIT = 'submit',
+  NEWLINE = 'newline',
+
+  // External tools
+  OPEN_EXTERNAL_EDITOR = 'openExternalEditor',
+  PASTE_CLIPBOARD_IMAGE = 'pasteClipboardImage',
+
+  // App level bindings
+  SHOW_ERROR_DETAILS = 'showErrorDetails',
+  TOGGLE_TOOL_DESCRIPTIONS = 'toggleToolDescriptions',
+  TOGGLE_IDE_CONTEXT_DETAIL = 'toggleIDEContextDetail',
+  QUIT = 'quit',
+  EXIT = 'exit',
+  SHOW_MORE_LINES = 'showMoreLines',
+
+  // Shell commands
+  REVERSE_SEARCH = 'reverseSearch',
+  SUBMIT_REVERSE_SEARCH = 'submitReverseSearch',
+  ACCEPT_SUGGESTION_REVERSE_SEARCH = 'acceptSuggestionReverseSearch',
+}
+
+/**
+ * Data-driven key binding structure for user configuration
+ */
+export interface KeyBinding {
+  /** The key name (e.g., 'a', 'return', 'tab', 'escape') */
+  key?: string;
+  /** The key sequence (e.g., '\x18' for Ctrl+X) - alternative to key name */
+  sequence?: string;
+  /** Control key requirement: true=must be pressed, false=must not be pressed, undefined=ignore */
+  ctrl?: boolean;
+  /** Shift key requirement: true=must be pressed, false=must not be pressed, undefined=ignore */
+  shift?: boolean;
+  /** Command/meta key requirement: true=must be pressed, false=must not be pressed, undefined=ignore */
+  command?: boolean;
+  /** Paste operation requirement: true=must be paste, false=must not be paste, undefined=ignore */
+  paste?: boolean;
+}
+
+/**
+ * Configuration type mapping commands to their key bindings
+ */
+export type KeyBindingConfig = {
+  readonly [C in Command]: readonly KeyBinding[];
+};
+
+/**
+ * Default key binding configuration
+ * Matches the original hard-coded logic exactly
+ */
+export const defaultKeyBindings: KeyBindingConfig = {
+  // Basic bindings
+  [Command.RETURN]: [{ key: 'return' }],
+  // Original: key.name === 'escape'
+  [Command.ESCAPE]: [{ key: 'escape' }],
+
+  // Cursor movement
+  // Original: key.ctrl && key.name === 'a'
+  [Command.HOME]: [{ key: 'a', ctrl: true }],
+  // Original: key.ctrl && key.name === 'e'
+  [Command.END]: [{ key: 'e', ctrl: true }],
+
+  // Text deletion
+  // Original: key.ctrl && key.name === 'k'
+  [Command.KILL_LINE_RIGHT]: [{ key: 'k', ctrl: true }],
+  // Original: key.ctrl && key.name === 'u'
+  [Command.KILL_LINE_LEFT]: [{ key: 'u', ctrl: true }],
+  // Original: key.ctrl && key.name === 'c'
+  [Command.CLEAR_INPUT]: [{ key: 'c', ctrl: true }],
+
+  // Screen control
+  // Original: key.ctrl && key.name === 'l'
+  [Command.CLEAR_SCREEN]: [{ key: 'l', ctrl: true }],
+
+  // History navigation
+  // Original: key.ctrl && key.name === 'p'
+  [Command.HISTORY_UP]: [{ key: 'p', ctrl: true }],
+  // Original: key.ctrl && key.name === 'n'
+  [Command.HISTORY_DOWN]: [{ key: 'n', ctrl: true }],
+  // Original: key.name === 'up'
+  [Command.NAVIGATION_UP]: [{ key: 'up' }],
+  // Original: key.name === 'down'
+  [Command.NAVIGATION_DOWN]: [{ key: 'down' }],
+
+  // Auto-completion
+  // Original: key.name === 'tab' || (key.name === 'return' && !key.ctrl)
+  [Command.ACCEPT_SUGGESTION]: [{ key: 'tab' }, { key: 'return', ctrl: false }],
+
+  // Text input
+  // Original: key.name === 'return' && !key.ctrl && !key.meta && !key.paste
+  [Command.SUBMIT]: [
+    {
+      key: 'return',
+      ctrl: false,
+      command: false,
+      paste: false,
+    },
+  ],
+  // Original: key.name === 'return' && (key.ctrl || key.meta || key.paste)
+  // Split into multiple data-driven bindings
+  [Command.NEWLINE]: [
+    { key: 'return', ctrl: true },
+    { key: 'return', command: true },
+    { key: 'return', paste: true },
+  ],
+
+  // External tools
+  // Original: key.ctrl && (key.name === 'x' || key.sequence === '\x18')
+  [Command.OPEN_EXTERNAL_EDITOR]: [
+    { key: 'x', ctrl: true },
+    { sequence: '\x18', ctrl: true },
+  ],
+  // Original: key.ctrl && key.name === 'v'
+  [Command.PASTE_CLIPBOARD_IMAGE]: [{ key: 'v', ctrl: true }],
+
+  // App level bindings
+  // Original: key.ctrl && key.name === 'o'
+  [Command.SHOW_ERROR_DETAILS]: [{ key: 'o', ctrl: true }],
+  // Original: key.ctrl && key.name === 't'
+  [Command.TOGGLE_TOOL_DESCRIPTIONS]: [{ key: 't', ctrl: true }],
+  // Original: key.ctrl && key.name === 'e'
+  [Command.TOGGLE_IDE_CONTEXT_DETAIL]: [{ key: 'e', ctrl: true }],
+  // Original: key.ctrl && (key.name === 'c' || key.name === 'C')
+  [Command.QUIT]: [
+    { key: 'c', ctrl: true },
+    { key: 'C', ctrl: true },
+  ],
+  // Original: key.ctrl && (key.name === 'd' || key.name === 'D')
+  [Command.EXIT]: [
+    { key: 'd', ctrl: true },
+    { key: 'D', ctrl: true },
+  ],
+  // Original: key.ctrl && key.name === 's'
+  [Command.SHOW_MORE_LINES]: [{ key: 's', ctrl: true }],
+
+  // Shell commands
+  // Original: key.ctrl && key.name === 'r'
+  [Command.REVERSE_SEARCH]: [{ key: 'r', ctrl: true }],
+  // Original: key.name === 'return' && !key.ctrl
+  // Note: original logic ONLY checked ctrl=false, ignored meta/shift/paste
+  [Command.SUBMIT_REVERSE_SEARCH]: [{ key: 'return', ctrl: false }],
+  // Original: key.name === 'tab'
+  [Command.ACCEPT_SUGGESTION_REVERSE_SEARCH]: [{ key: 'tab' }],
+};
diff --git a/packages/cli/src/ui/App.tsx b/packages/cli/src/ui/App.tsx
index e3c77ad0..7ee9405f 100644
--- a/packages/cli/src/ui/App.tsx
+++ b/packages/cli/src/ui/App.tsx
@@ -13,8 +13,6 @@ import {
   Text,
   useStdin,
   useStdout,
-  useInput,
-  type Key as InkKeyType,
 } from 'ink';
 import { StreamingState, type HistoryItem, MessageType } from './types.js';
 import { useTerminalSize } from './hooks/useTerminalSize.js';
@@ -81,6 +79,8 @@ import { useBracketedPaste } from './hooks/useBracketedPaste.js';
 import { useTextBuffer } from './components/shared/text-buffer.js';
 import { useVimMode, VimModeProvider } from './contexts/VimModeContext.js';
 import { useVim } from './hooks/vim.js';
+import { useKeypress, Key } from './hooks/useKeypress.js';
+import { keyMatchers, Command } from './keyMatchers.js';
 import * as fs from 'fs';
 import { UpdateNotification } from './components/UpdateNotification.js';
 import {
@@ -613,50 +613,71 @@ const App = ({ config, settings, startupWarnings = [], version }: AppProps) => {
     [handleSlashCommand],
   );
 
-  useInput((input: string, key: InkKeyType) => {
-    let enteringConstrainHeightMode = false;
-    if (!constrainHeight) {
-      // Automatically re-enter constrain height mode if the user types
-      // anything. When constrainHeight==false, the user will experience
-      // significant flickering so it is best to disable it immediately when
-      // the user starts interacting with the app.
-      enteringConstrainHeightMode = true;
-      setConstrainHeight(true);
-    }
+  const handleGlobalKeypress = useCallback(
+    (key: Key) => {
+      let enteringConstrainHeightMode = false;
+      if (!constrainHeight) {
+        enteringConstrainHeightMode = true;
+        setConstrainHeight(true);
+      }
 
-    if (key.ctrl && input === 'o') {
-      setShowErrorDetails((prev) => !prev);
-    } else if (key.ctrl && input === 't') {
-      const newValue = !showToolDescriptions;
-      setShowToolDescriptions(newValue);
+      if (keyMatchers[Command.SHOW_ERROR_DETAILS](key)) {
+        setShowErrorDetails((prev) => !prev);
+      } else if (keyMatchers[Command.TOGGLE_TOOL_DESCRIPTIONS](key)) {
+        const newValue = !showToolDescriptions;
+        setShowToolDescriptions(newValue);
 
-      const mcpServers = config.getMcpServers();
-      if (Object.keys(mcpServers || {}).length > 0) {
-        handleSlashCommand(newValue ? '/mcp desc' : '/mcp nodesc');
+        const mcpServers = config.getMcpServers();
+        if (Object.keys(mcpServers || {}).length > 0) {
+          handleSlashCommand(newValue ? '/mcp desc' : '/mcp nodesc');
+        }
+      } else if (
+        keyMatchers[Command.TOGGLE_IDE_CONTEXT_DETAIL](key) &&
+        config.getIdeMode() &&
+        ideContextState
+      ) {
+        // Show IDE status when in IDE mode and context is available.
+        handleSlashCommand('/ide status');
+      } else if (keyMatchers[Command.QUIT](key)) {
+        // When authenticating, let AuthInProgress component handle Ctrl+C.
+        if (isAuthenticating) {
+          return;
+        }
+        handleExit(ctrlCPressedOnce, setCtrlCPressedOnce, ctrlCTimerRef);
+      } else if (keyMatchers[Command.EXIT](key)) {
+        if (buffer.text.length > 0) {
+          return;
+        }
+        handleExit(ctrlDPressedOnce, setCtrlDPressedOnce, ctrlDTimerRef);
+      } else if (
+        keyMatchers[Command.SHOW_MORE_LINES](key) &&
+        !enteringConstrainHeightMode
+      ) {
+        setConstrainHeight(false);
       }
-    } else if (
-      key.ctrl &&
-      input === 'e' &&
-      config.getIdeMode() &&
-      ideContextState
-    ) {
-      handleSlashCommand('/ide status');
-    } else if (key.ctrl && (input === 'c' || input === 'C')) {
-      if (isAuthenticating) {
-        // Let AuthInProgress component handle the input.
-        return;
-      }
-      handleExit(ctrlCPressedOnce, setCtrlCPressedOnce, ctrlCTimerRef);
-    } else if (key.ctrl && (input === 'd' || input === 'D')) {
-      if (buffer.text.length > 0) {
-        // Do nothing if there is text in the input.
-        return;
-      }
-      handleExit(ctrlDPressedOnce, setCtrlDPressedOnce, ctrlDTimerRef);
-    } else if (key.ctrl && input === 's' && !enteringConstrainHeightMode) {
-      setConstrainHeight(false);
-    }
-  });
+    },
+    [
+      constrainHeight,
+      setConstrainHeight,
+      setShowErrorDetails,
+      showToolDescriptions,
+      setShowToolDescriptions,
+      config,
+      ideContextState,
+      handleExit,
+      ctrlCPressedOnce,
+      setCtrlCPressedOnce,
+      ctrlCTimerRef,
+      buffer.text.length,
+      ctrlDPressedOnce,
+      setCtrlDPressedOnce,
+      ctrlDTimerRef,
+      handleSlashCommand,
+      isAuthenticating,
+    ],
+  );
+
+  useKeypress(handleGlobalKeypress, { isActive: true });
 
   useEffect(() => {
     if (config) {
diff --git a/packages/cli/src/ui/components/InputPrompt.tsx b/packages/cli/src/ui/components/InputPrompt.tsx
index 7250afea..78b3b96b 100644
--- a/packages/cli/src/ui/components/InputPrompt.tsx
+++ b/packages/cli/src/ui/components/InputPrompt.tsx
@@ -17,6 +17,7 @@ import { useShellHistory } from '../hooks/useShellHistory.js';
 import { useReverseSearchCompletion } from '../hooks/useReverseSearchCompletion.js';
 import { useCommandCompletion } from '../hooks/useCommandCompletion.js';
 import { useKeypress, Key } from '../hooks/useKeypress.js';
+import { keyMatchers, Command } from '../keyMatchers.js';
 import { CommandContext, SlashCommand } from '../commands/types.js';
 import { Config } from '@google/gemini-cli-core';
 import {
@@ -221,7 +222,7 @@ export const InputPrompt: React.FC<InputPromptProps> = ({
         return;
       }
 
-      if (key.name === 'escape') {
+      if (keyMatchers[Command.ESCAPE](key)) {
         if (reverseSearchActive) {
           setReverseSearchActive(false);
           reverseSearchCompletion.resetCompletionState();
@@ -234,7 +235,6 @@ export const InputPrompt: React.FC<InputPromptProps> = ({
           buffer.moveToOffset(offset);
           return;
         }
-
         if (shellModeActive) {
           setShellModeActive(false);
           return;
@@ -246,14 +246,14 @@ export const InputPrompt: React.FC<InputPromptProps> = ({
         }
       }
 
-      if (shellModeActive && key.ctrl && key.name === 'r') {
+      if (shellModeActive && keyMatchers[Command.REVERSE_SEARCH](key)) {
         setReverseSearchActive(true);
         setTextBeforeReverseSearch(buffer.text);
         setCursorPosition(buffer.cursor);
         return;
       }
 
-      if (key.ctrl && key.name === 'l') {
+      if (keyMatchers[Command.CLEAR_SCREEN](key)) {
         onClearScreen();
         return;
       }
@@ -268,15 +268,15 @@ export const InputPrompt: React.FC<InputPromptProps> = ({
         } = reverseSearchCompletion;
 
         if (showSuggestions) {
-          if (key.name === 'up') {
+          if (keyMatchers[Command.NAVIGATION_UP](key)) {
             navigateUp();
             return;
           }
-          if (key.name === 'down') {
+          if (keyMatchers[Command.NAVIGATION_DOWN](key)) {
             navigateDown();
             return;
           }
-          if (key.name === 'tab') {
+          if (keyMatchers[Command.ACCEPT_SUGGESTION_REVERSE_SEARCH](key)) {
             reverseSearchCompletion.handleAutocomplete(activeSuggestionIndex);
             reverseSearchCompletion.resetCompletionState();
             setReverseSearchActive(false);
@@ -284,7 +284,7 @@ export const InputPrompt: React.FC<InputPromptProps> = ({
           }
         }
 
-        if (key.name === 'return' && !key.ctrl) {
+        if (keyMatchers[Command.SUBMIT_REVERSE_SEARCH](key)) {
           const textToSubmit =
             showSuggestions && activeSuggestionIndex > -1
               ? suggestions[activeSuggestionIndex].value
@@ -296,30 +296,39 @@ export const InputPrompt: React.FC<InputPromptProps> = ({
         }
 
         // Prevent up/down from falling through to regular history navigation
-        if (key.name === 'up' || key.name === 'down') {
+        if (
+          keyMatchers[Command.NAVIGATION_UP](key) ||
+          keyMatchers[Command.NAVIGATION_DOWN](key)
+        ) {
           return;
         }
       }
 
       // If the command is a perfect match, pressing enter should execute it.
-      if (completion.isPerfectMatch && key.name === 'return') {
+      if (completion.isPerfectMatch && keyMatchers[Command.RETURN](key)) {
         handleSubmitAndClear(buffer.text);
         return;
       }
 
       if (completion.showSuggestions) {
         if (completion.suggestions.length > 1) {
-          if (key.name === 'up' || (key.ctrl && key.name === 'p')) {
+          if (
+            keyMatchers[Command.NAVIGATION_UP](key) ||
+            keyMatchers[Command.HISTORY_UP](key)
+          ) {
             completion.navigateUp();
             return;
           }
-          if (key.name === 'down' || (key.ctrl && key.name === 'n')) {
+          if (
+            keyMatchers[Command.NAVIGATION_DOWN](key) ||
+            keyMatchers[Command.HISTORY_DOWN](key)
+          ) {
             completion.navigateDown();
             return;
           }
         }
 
-        if (key.name === 'tab' || (key.name === 'return' && !key.ctrl)) {
+        if (keyMatchers[Command.ACCEPT_SUGGESTION](key)) {
           if (completion.suggestions.length > 0) {
             const targetIndex =
               completion.activeSuggestionIndex === -1
@@ -334,17 +343,17 @@ export const InputPrompt: React.FC<InputPromptProps> = ({
       }
 
       if (!shellModeActive) {
-        if (key.ctrl && key.name === 'p') {
+        if (keyMatchers[Command.HISTORY_UP](key)) {
           inputHistory.navigateUp();
           return;
         }
-        if (key.ctrl && key.name === 'n') {
+        if (keyMatchers[Command.HISTORY_DOWN](key)) {
           inputHistory.navigateDown();
           return;
         }
         // Handle arrow-up/down for history on single-line or at edges
         if (
-          key.name === 'up' &&
+          keyMatchers[Command.NAVIGATION_UP](key) &&
           (buffer.allVisualLines.length === 1 ||
             (buffer.visualCursor[0] === 0 && buffer.visualScrollRow === 0))
         ) {
@@ -352,7 +361,7 @@ export const InputPrompt: React.FC<InputPromptProps> = ({
           return;
         }
         if (
-          key.name === 'down' &&
+          keyMatchers[Command.NAVIGATION_DOWN](key) &&
           (buffer.allVisualLines.length === 1 ||
             buffer.visualCursor[0] === buffer.allVisualLines.length - 1)
         ) {
@@ -360,18 +369,20 @@ export const InputPrompt: React.FC<InputPromptProps> = ({
           return;
         }
       } else {
-        if (key.name === 'up') {
+        // Shell History Navigation
+        if (keyMatchers[Command.NAVIGATION_UP](key)) {
           const prevCommand = shellHistory.getPreviousCommand();
           if (prevCommand !== null) buffer.setText(prevCommand);
           return;
         }
-        if (key.name === 'down') {
+        if (keyMatchers[Command.NAVIGATION_DOWN](key)) {
           const nextCommand = shellHistory.getNextCommand();
           if (nextCommand !== null) buffer.setText(nextCommand);
           return;
         }
       }
-      if (key.name === 'return' && !key.ctrl && !key.meta && !key.paste) {
+
+      if (keyMatchers[Command.SUBMIT](key)) {
         if (buffer.text.trim()) {
           const [row, col] = buffer.cursor;
           const line = buffer.lines[row];
@@ -387,23 +398,23 @@ export const InputPrompt: React.FC<InputPromptProps> = ({
       }
 
       // Newline insertion
-      if (key.name === 'return' && (key.ctrl || key.meta || key.paste)) {
+      if (keyMatchers[Command.NEWLINE](key)) {
         buffer.newline();
         return;
       }
 
       // Ctrl+A (Home) / Ctrl+E (End)
-      if (key.ctrl && key.name === 'a') {
+      if (keyMatchers[Command.HOME](key)) {
         buffer.move('home');
         return;
       }
-      if (key.ctrl && key.name === 'e') {
+      if (keyMatchers[Command.END](key)) {
         buffer.move('end');
         buffer.moveToOffset(cpLen(buffer.text));
         return;
       }
       // Ctrl+C (Clear input)
-      if (key.ctrl && key.name === 'c') {
+      if (keyMatchers[Command.CLEAR_INPUT](key)) {
         if (buffer.text.length > 0) {
           buffer.setText('');
           resetCompletionState();
@@ -413,24 +424,23 @@ export const InputPrompt: React.FC<InputPromptProps> = ({
       }
 
       // Kill line commands
-      if (key.ctrl && key.name === 'k') {
+      if (keyMatchers[Command.KILL_LINE_RIGHT](key)) {
         buffer.killLineRight();
         return;
       }
-      if (key.ctrl && key.name === 'u') {
+      if (keyMatchers[Command.KILL_LINE_LEFT](key)) {
         buffer.killLineLeft();
         return;
       }
 
       // External editor
-      const isCtrlX = key.ctrl && (key.name === 'x' || key.sequence === '\x18');
-      if (isCtrlX) {
+      if (keyMatchers[Command.OPEN_EXTERNAL_EDITOR](key)) {
         buffer.openInExternalEditor();
         return;
       }
 
       // Ctrl+V for clipboard image paste
-      if (key.ctrl && key.name === 'v') {
+      if (keyMatchers[Command.PASTE_CLIPBOARD_IMAGE](key)) {
         handleClipboardImage();
         return;
       }
diff --git a/packages/cli/src/ui/keyMatchers.test.ts b/packages/cli/src/ui/keyMatchers.test.ts
new file mode 100644
index 00000000..16951e79
--- /dev/null
+++ b/packages/cli/src/ui/keyMatchers.test.ts
@@ -0,0 +1,338 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { describe, it, expect } from 'vitest';
+import { keyMatchers, Command, createKeyMatchers } from './keyMatchers.js';
+import { KeyBindingConfig, defaultKeyBindings } from '../config/keyBindings.js';
+import type { Key } from './hooks/useKeypress.js';
+
+describe('keyMatchers', () => {
+  const createKey = (name: string, mods: Partial<Key> = {}): Key => ({
+    name,
+    ctrl: false,
+    meta: false,
+    shift: false,
+    paste: false,
+    sequence: name,
+    ...mods,
+  });
+
+  // Original hard-coded logic (for comparison)
+  const originalMatchers = {
+    [Command.HOME]: (key: Key) => key.ctrl && key.name === 'a',
+    [Command.END]: (key: Key) => key.ctrl && key.name === 'e',
+    [Command.KILL_LINE_RIGHT]: (key: Key) => key.ctrl && key.name === 'k',
+    [Command.KILL_LINE_LEFT]: (key: Key) => key.ctrl && key.name === 'u',
+    [Command.CLEAR_INPUT]: (key: Key) => key.ctrl && key.name === 'c',
+    [Command.CLEAR_SCREEN]: (key: Key) => key.ctrl && key.name === 'l',
+    [Command.HISTORY_UP]: (key: Key) => key.ctrl && key.name === 'p',
+    [Command.HISTORY_DOWN]: (key: Key) => key.ctrl && key.name === 'n',
+    [Command.NAVIGATION_UP]: (key: Key) => key.name === 'up',
+    [Command.NAVIGATION_DOWN]: (key: Key) => key.name === 'down',
+    [Command.ACCEPT_SUGGESTION]: (key: Key) =>
+      key.name === 'tab' || (key.name === 'return' && !key.ctrl),
+    [Command.ESCAPE]: (key: Key) => key.name === 'escape',
+    [Command.SUBMIT]: (key: Key) =>
+      key.name === 'return' && !key.ctrl && !key.meta && !key.paste,
+    [Command.NEWLINE]: (key: Key) =>
+      key.name === 'return' && (key.ctrl || key.meta || key.paste),
+    [Command.OPEN_EXTERNAL_EDITOR]: (key: Key) =>
+      key.ctrl && (key.name === 'x' || key.sequence === '\x18'),
+    [Command.PASTE_CLIPBOARD_IMAGE]: (key: Key) => key.ctrl && key.name === 'v',
+    [Command.SHOW_ERROR_DETAILS]: (key: Key) => key.ctrl && key.name === 'o',
+    [Command.TOGGLE_TOOL_DESCRIPTIONS]: (key: Key) =>
+      key.ctrl && key.name === 't',
+    [Command.TOGGLE_IDE_CONTEXT_DETAIL]: (key: Key) =>
+      key.ctrl && key.name === 'e',
+    [Command.QUIT]: (key: Key) =>
+      key.ctrl && (key.name === 'c' || key.name === 'C'),
+    [Command.EXIT]: (key: Key) =>
+      key.ctrl && (key.name === 'd' || key.name === 'D'),
+    [Command.SHOW_MORE_LINES]: (key: Key) => key.ctrl && key.name === 's',
+    [Command.REVERSE_SEARCH]: (key: Key) => key.ctrl && key.name === 'r',
+    [Command.SUBMIT_REVERSE_SEARCH]: (key: Key) =>
+      key.name === 'return' && !key.ctrl,
+    [Command.ACCEPT_SUGGESTION_REVERSE_SEARCH]: (key: Key) =>
+      key.name === 'tab',
+  };
+
+  // Test data for each command with positive and negative test cases
+  const testCases = [
+    // Basic bindings
+    {
+      command: Command.ESCAPE,
+      positive: [createKey('escape'), createKey('escape', { ctrl: true })],
+      negative: [createKey('e'), createKey('esc')],
+    },
+
+    // Cursor movement
+    {
+      command: Command.HOME,
+      positive: [createKey('a', { ctrl: true })],
+      negative: [
+        createKey('a'),
+        createKey('a', { shift: true }),
+        createKey('b', { ctrl: true }),
+      ],
+    },
+    {
+      command: Command.END,
+      positive: [createKey('e', { ctrl: true })],
+      negative: [
+        createKey('e'),
+        createKey('e', { shift: true }),
+        createKey('a', { ctrl: true }),
+      ],
+    },
+
+    // Text deletion
+    {
+      command: Command.KILL_LINE_RIGHT,
+      positive: [createKey('k', { ctrl: true })],
+      negative: [createKey('k'), createKey('l', { ctrl: true })],
+    },
+    {
+      command: Command.KILL_LINE_LEFT,
+      positive: [createKey('u', { ctrl: true })],
+      negative: [createKey('u'), createKey('k', { ctrl: true })],
+    },
+    {
+      command: Command.CLEAR_INPUT,
+      positive: [createKey('c', { ctrl: true })],
+      negative: [createKey('c'), createKey('k', { ctrl: true })],
+    },
+
+    // Screen control
+    {
+      command: Command.CLEAR_SCREEN,
+      positive: [createKey('l', { ctrl: true })],
+      negative: [createKey('l'), createKey('k', { ctrl: true })],
+    },
+
+    // History navigation
+    {
+      command: Command.HISTORY_UP,
+      positive: [createKey('p', { ctrl: true })],
+      negative: [createKey('p'), createKey('up')],
+    },
+    {
+      command: Command.HISTORY_DOWN,
+      positive: [createKey('n', { ctrl: true })],
+      negative: [createKey('n'), createKey('down')],
+    },
+    {
+      command: Command.NAVIGATION_UP,
+      positive: [createKey('up'), createKey('up', { ctrl: true })],
+      negative: [createKey('p'), createKey('u')],
+    },
+    {
+      command: Command.NAVIGATION_DOWN,
+      positive: [createKey('down'), createKey('down', { ctrl: true })],
+      negative: [createKey('n'), createKey('d')],
+    },
+
+    // Auto-completion
+    {
+      command: Command.ACCEPT_SUGGESTION,
+      positive: [createKey('tab'), createKey('return')],
+      negative: [createKey('return', { ctrl: true }), createKey('space')],
+    },
+
+    // Text input
+    {
+      command: Command.SUBMIT,
+      positive: [createKey('return')],
+      negative: [
+        createKey('return', { ctrl: true }),
+        createKey('return', { meta: true }),
+        createKey('return', { paste: true }),
+      ],
+    },
+    {
+      command: Command.NEWLINE,
+      positive: [
+        createKey('return', { ctrl: true }),
+        createKey('return', { meta: true }),
+        createKey('return', { paste: true }),
+      ],
+      negative: [createKey('return'), createKey('n')],
+    },
+
+    // External tools
+    {
+      command: Command.OPEN_EXTERNAL_EDITOR,
+      positive: [
+        createKey('x', { ctrl: true }),
+        { ...createKey('\x18'), sequence: '\x18', ctrl: true },
+      ],
+      negative: [createKey('x'), createKey('c', { ctrl: true })],
+    },
+    {
+      command: Command.PASTE_CLIPBOARD_IMAGE,
+      positive: [createKey('v', { ctrl: true })],
+      negative: [createKey('v'), createKey('c', { ctrl: true })],
+    },
+
+    // App level bindings
+    {
+      command: Command.SHOW_ERROR_DETAILS,
+      positive: [createKey('o', { ctrl: true })],
+      negative: [createKey('o'), createKey('e', { ctrl: true })],
+    },
+    {
+      command: Command.TOGGLE_TOOL_DESCRIPTIONS,
+      positive: [createKey('t', { ctrl: true })],
+      negative: [createKey('t'), createKey('s', { ctrl: true })],
+    },
+    {
+      command: Command.TOGGLE_IDE_CONTEXT_DETAIL,
+      positive: [createKey('e', { ctrl: true })],
+      negative: [createKey('e'), createKey('t', { ctrl: true })],
+    },
+    {
+      command: Command.QUIT,
+      positive: [
+        createKey('c', { ctrl: true }),
+        createKey('C', { ctrl: true }),
+      ],
+      negative: [createKey('c'), createKey('d', { ctrl: true })],
+    },
+    {
+      command: Command.EXIT,
+      positive: [
+        createKey('d', { ctrl: true }),
+        createKey('D', { ctrl: true }),
+      ],
+      negative: [createKey('d'), createKey('c', { ctrl: true })],
+    },
+    {
+      command: Command.SHOW_MORE_LINES,
+      positive: [createKey('s', { ctrl: true })],
+      negative: [createKey('s'), createKey('l', { ctrl: true })],
+    },
+
+    // Shell commands
+    {
+      command: Command.REVERSE_SEARCH,
+      positive: [createKey('r', { ctrl: true })],
+      negative: [createKey('r'), createKey('s', { ctrl: true })],
+    },
+    {
+      command: Command.SUBMIT_REVERSE_SEARCH,
+      positive: [createKey('return')],
+      negative: [createKey('return', { ctrl: true }), createKey('tab')],
+    },
+    {
+      command: Command.ACCEPT_SUGGESTION_REVERSE_SEARCH,
+      positive: [createKey('tab'), createKey('tab', { ctrl: true })],
+      negative: [createKey('return'), createKey('space')],
+    },
+  ];
+
+  describe('Data-driven key binding matches original logic', () => {
+    testCases.forEach(({ command, positive, negative }) => {
+      it(`should match ${command} correctly`, () => {
+        positive.forEach((key) => {
+          expect(
+            keyMatchers[command](key),
+            `Expected ${command} to match ${JSON.stringify(key)}`,
+          ).toBe(true);
+          expect(
+            originalMatchers[command](key),
+            `Original matcher should also match ${JSON.stringify(key)}`,
+          ).toBe(true);
+        });
+
+        negative.forEach((key) => {
+          expect(
+            keyMatchers[command](key),
+            `Expected ${command} to NOT match ${JSON.stringify(key)}`,
+          ).toBe(false);
+          expect(
+            originalMatchers[command](key),
+            `Original matcher should also NOT match ${JSON.stringify(key)}`,
+          ).toBe(false);
+        });
+      });
+    });
+
+    it('should properly handle ACCEPT_SUGGESTION_REVERSE_SEARCH cases', () => {
+      expect(
+        keyMatchers[Command.ACCEPT_SUGGESTION_REVERSE_SEARCH](
+          createKey('return', { ctrl: true }),
+        ),
+      ).toBe(false); // ctrl must be false
+      expect(
+        keyMatchers[Command.ACCEPT_SUGGESTION_REVERSE_SEARCH](createKey('tab')),
+      ).toBe(true);
+      expect(
+        keyMatchers[Command.ACCEPT_SUGGESTION_REVERSE_SEARCH](
+          createKey('tab', { ctrl: true }),
+        ),
+      ).toBe(true); // modifiers ignored
+    });
+  });
+
+  describe('Custom key bindings', () => {
+    it('should work with custom configuration', () => {
+      const customConfig: KeyBindingConfig = {
+        ...defaultKeyBindings,
+        [Command.HOME]: [{ key: 'h', ctrl: true }, { key: '0' }],
+      };
+
+      const customMatchers = createKeyMatchers(customConfig);
+
+      expect(customMatchers[Command.HOME](createKey('h', { ctrl: true }))).toBe(
+        true,
+      );
+      expect(customMatchers[Command.HOME](createKey('0'))).toBe(true);
+      expect(customMatchers[Command.HOME](createKey('a', { ctrl: true }))).toBe(
+        false,
+      );
+    });
+
+    it('should support multiple key bindings for same command', () => {
+      const config: KeyBindingConfig = {
+        ...defaultKeyBindings,
+        [Command.QUIT]: [
+          { key: 'q', ctrl: true },
+          { key: 'q', command: true },
+        ],
+      };
+
+      const matchers = createKeyMatchers(config);
+      expect(matchers[Command.QUIT](createKey('q', { ctrl: true }))).toBe(true);
+      expect(matchers[Command.QUIT](createKey('q', { meta: true }))).toBe(true);
+    });
+  });
+
+  describe('Edge Cases', () => {
+    it('should handle empty binding arrays', () => {
+      const config: KeyBindingConfig = {
+        ...defaultKeyBindings,
+        [Command.HOME]: [],
+      };
+
+      const matchers = createKeyMatchers(config);
+      expect(matchers[Command.HOME](createKey('a', { ctrl: true }))).toBe(
+        false,
+      );
+    });
+
+    it('should handle case sensitivity', () => {
+      const config: KeyBindingConfig = {
+        ...defaultKeyBindings,
+        [Command.QUIT]: [{ key: 'Q', ctrl: true }],
+      };
+
+      const matchers = createKeyMatchers(config);
+      expect(matchers[Command.QUIT](createKey('Q', { ctrl: true }))).toBe(true);
+      expect(matchers[Command.QUIT](createKey('q', { ctrl: true }))).toBe(
+        false,
+      );
+    });
+  });
+});
diff --git a/packages/cli/src/ui/keyMatchers.ts b/packages/cli/src/ui/keyMatchers.ts
new file mode 100644
index 00000000..651343af
--- /dev/null
+++ b/packages/cli/src/ui/keyMatchers.ts
@@ -0,0 +1,105 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import type { Key } from './hooks/useKeypress.js';
+import {
+  Command,
+  KeyBinding,
+  KeyBindingConfig,
+  defaultKeyBindings,
+} from '../config/keyBindings.js';
+
+/**
+ * Matches a KeyBinding against an actual Key press
+ * Pure data-driven matching logic
+ */
+function matchKeyBinding(keyBinding: KeyBinding, key: Key): boolean {
+  // Either key name or sequence must match (but not both should be defined)
+  let keyMatches = false;
+
+  if (keyBinding.key !== undefined) {
+    keyMatches = keyBinding.key === key.name;
+  } else if (keyBinding.sequence !== undefined) {
+    keyMatches = keyBinding.sequence === key.sequence;
+  } else {
+    // Neither key nor sequence defined - invalid binding
+    return false;
+  }
+
+  if (!keyMatches) {
+    return false;
+  }
+
+  // Check modifiers - follow original logic:
+  // undefined = ignore this modifier (original behavior)
+  // true = modifier must be pressed
+  // false = modifier must NOT be pressed
+
+  if (keyBinding.ctrl !== undefined && key.ctrl !== keyBinding.ctrl) {
+    return false;
+  }
+
+  if (keyBinding.shift !== undefined && key.shift !== keyBinding.shift) {
+    return false;
+  }
+
+  if (keyBinding.command !== undefined && key.meta !== keyBinding.command) {
+    return false;
+  }
+
+  if (keyBinding.paste !== undefined && key.paste !== keyBinding.paste) {
+    return false;
+  }
+
+  return true;
+}
+
+/**
+ * Checks if a key matches any of the bindings for a command
+ */
+function matchCommand(
+  command: Command,
+  key: Key,
+  config: KeyBindingConfig = defaultKeyBindings,
+): boolean {
+  const bindings = config[command];
+  return bindings.some((binding) => matchKeyBinding(binding, key));
+}
+
+/**
+ * Key matcher function type
+ */
+type KeyMatcher = (key: Key) => boolean;
+
+/**
+ * Type for key matchers mapped to Command enum
+ */
+export type KeyMatchers = {
+  readonly [C in Command]: KeyMatcher;
+};
+
+/**
+ * Creates key matchers from a key binding configuration
+ */
+export function createKeyMatchers(
+  config: KeyBindingConfig = defaultKeyBindings,
+): KeyMatchers {
+  const matchers = {} as { [C in Command]: KeyMatcher };
+
+  for (const command of Object.values(Command)) {
+    matchers[command] = (key: Key) => matchCommand(command, key, config);
+  }
+
+  return matchers as KeyMatchers;
+}
+
+/**
+ * Default key binding matchers using the default configuration
+ */
+export const keyMatchers: KeyMatchers = createKeyMatchers(defaultKeyBindings);
+
+// Re-export Command for convenience
+export { Command };

From 6b19c8bd5570fbe349ce47a0c39251e1ac9a2f44 Mon Sep 17 00:00:00 2001
From: JAYADITYA <96861162+JayadityaGit@users.noreply.github.com>
Date: Sat, 9 Aug 2025 12:54:21 +0530
Subject: [PATCH 076/107] feat: add humorous tip for new line shortcut in
 Gemini CLI (#5666)

Co-authored-by: gemini-code-assist[bot] <176961590+gemini-code-assist[bot]@users.noreply.github.com>
Co-authored-by: Jacob Richman <jacob314@gmail.com>
---
 packages/cli/src/ui/hooks/usePhraseCycler.ts | 1 +
 1 file changed, 1 insertion(+)

diff --git a/packages/cli/src/ui/hooks/usePhraseCycler.ts b/packages/cli/src/ui/hooks/usePhraseCycler.ts
index 73c8ccf0..0bf2c2a2 100644
--- a/packages/cli/src/ui/hooks/usePhraseCycler.ts
+++ b/packages/cli/src/ui/hooks/usePhraseCycler.ts
@@ -135,6 +135,7 @@ export const WITTY_LOADING_PHRASES = [
   "It's not a bug, it's a feature... of this loading screen.",
   'Have you tried turning it off and on again? (The loading screen, not me.)',
   'Constructing additional pylons...',
+  'New line? That’s Ctrl+J.',
 ];
 
 export const PHRASE_CHANGE_INTERVAL_MS = 15000;

From 34434cd4aad088fe001708ff4685d7c97be099eb Mon Sep 17 00:00:00 2001
From: Yuki Okita <yuki.work0512@gmail.com>
Date: Sun, 10 Aug 2025 04:50:53 +0900
Subject: [PATCH 077/107] feat: drop load-memory-from-include-directories
 option from cli args (#5866)

---
 packages/cli/src/config/config.ts | 11 +----------
 1 file changed, 1 insertion(+), 10 deletions(-)

diff --git a/packages/cli/src/config/config.ts b/packages/cli/src/config/config.ts
index d9460946..52600e42 100644
--- a/packages/cli/src/config/config.ts
+++ b/packages/cli/src/config/config.ts
@@ -70,7 +70,6 @@ export interface CliArgs {
   ideModeFeature: boolean | undefined;
   proxy: string | undefined;
   includeDirectories: string[] | undefined;
-  loadMemoryFromIncludeDirectories: boolean | undefined;
 }
 
 export async function parseArguments(): Promise<CliArgs> {
@@ -219,12 +218,6 @@ export async function parseArguments(): Promise<CliArgs> {
             // Handle comma-separated values
             dirs.flatMap((dir) => dir.split(',').map((d) => d.trim())),
         })
-        .option('load-memory-from-include-directories', {
-          type: 'boolean',
-          description:
-            'If true, when refreshing memory, GEMINI.md files should be loaded from all directories that are added. If false, GEMINI.md files should only be loaded from the primary working directory.',
-          default: false,
-        })
         .check((argv) => {
           if (argv.prompt && argv.promptInteractive) {
             throw new Error(
@@ -423,9 +416,7 @@ export async function loadCliConfig(
     targetDir: process.cwd(),
     includeDirectories,
     loadMemoryFromIncludeDirectories:
-      argv.loadMemoryFromIncludeDirectories ||
-      settings.loadMemoryFromIncludeDirectories ||
-      false,
+      settings.loadMemoryFromIncludeDirectories || false,
     debugMode,
     question,
     fullContext: argv.allFiles || argv.all_files || false,

From 0dea7233b65b480466e4da62db9127205b57a6d0 Mon Sep 17 00:00:00 2001
From: fuyou <imshuazi@126.com>
Date: Sun, 10 Aug 2025 06:26:43 +0800
Subject: [PATCH 078/107] feat(cli) - enhance input UX with double ESC clear
 (#4453)

Co-authored-by: Jacob Richman <jacob314@gmail.com>
---
 packages/cli/src/ui/App.tsx                   |   9 ++
 .../src/ui/components/InputPrompt.test.tsx    | 100 ++++++++++++++++++
 .../cli/src/ui/components/InputPrompt.tsx     |  67 +++++++++++-
 3 files changed, 174 insertions(+), 2 deletions(-)

diff --git a/packages/cli/src/ui/App.tsx b/packages/cli/src/ui/App.tsx
index 7ee9405f..a52236f8 100644
--- a/packages/cli/src/ui/App.tsx
+++ b/packages/cli/src/ui/App.tsx
@@ -190,6 +190,7 @@ const App = ({ config, settings, startupWarnings = [], version }: AppProps) => {
   const [ideContextState, setIdeContextState] = useState<
     IdeContext | undefined
   >();
+  const [showEscapePrompt, setShowEscapePrompt] = useState(false);
   const [isProcessing, setIsProcessing] = useState<boolean>(false);
 
   useEffect(() => {
@@ -224,6 +225,11 @@ const App = ({ config, settings, startupWarnings = [], version }: AppProps) => {
   const openPrivacyNotice = useCallback(() => {
     setShowPrivacyNotice(true);
   }, []);
+
+  const handleEscapePromptChange = useCallback((showPrompt: boolean) => {
+    setShowEscapePrompt(showPrompt);
+  }, []);
+
   const initialPromptSubmitted = useRef(false);
 
   const errorCount = useMemo(
@@ -1055,6 +1061,8 @@ const App = ({ config, settings, startupWarnings = [], version }: AppProps) => {
                     <Text color={Colors.AccentYellow}>
                       Press Ctrl+D again to exit.
                     </Text>
+                  ) : showEscapePrompt ? (
+                    <Text color={Colors.Gray}>Press Esc again to clear.</Text>
                   ) : (
                     <ContextSummaryDisplay
                       ideContext={ideContextState}
@@ -1105,6 +1113,7 @@ const App = ({ config, settings, startupWarnings = [], version }: AppProps) => {
                   commandContext={commandContext}
                   shellModeActive={shellModeActive}
                   setShellModeActive={setShellModeActive}
+                  onEscapePromptChange={handleEscapePromptChange}
                   focus={isFocused}
                   vimHandleInput={vimHandleInput}
                   placeholder={placeholder}
diff --git a/packages/cli/src/ui/components/InputPrompt.test.tsx b/packages/cli/src/ui/components/InputPrompt.test.tsx
index f050ba07..a29a095a 100644
--- a/packages/cli/src/ui/components/InputPrompt.test.tsx
+++ b/packages/cli/src/ui/components/InputPrompt.test.tsx
@@ -1191,6 +1191,106 @@ describe('InputPrompt', () => {
     });
   });
 
+  describe('enhanced input UX - double ESC clear functionality', () => {
+    it('should clear buffer on second ESC press', async () => {
+      const onEscapePromptChange = vi.fn();
+      props.onEscapePromptChange = onEscapePromptChange;
+      props.buffer.setText('text to clear');
+
+      const { stdin, unmount } = render(<InputPrompt {...props} />);
+      await wait();
+
+      stdin.write('\x1B');
+      await wait();
+
+      stdin.write('\x1B');
+      await wait();
+
+      expect(props.buffer.setText).toHaveBeenCalledWith('');
+      expect(mockCommandCompletion.resetCompletionState).toHaveBeenCalled();
+      unmount();
+    });
+
+    it('should reset escape state on any non-ESC key', async () => {
+      const onEscapePromptChange = vi.fn();
+      props.onEscapePromptChange = onEscapePromptChange;
+      props.buffer.setText('some text');
+
+      const { stdin, unmount } = render(<InputPrompt {...props} />);
+      await wait();
+
+      stdin.write('\x1B');
+      await wait();
+
+      expect(onEscapePromptChange).toHaveBeenCalledWith(true);
+
+      stdin.write('a');
+      await wait();
+
+      expect(onEscapePromptChange).toHaveBeenCalledWith(false);
+      unmount();
+    });
+
+    it('should handle ESC in shell mode by disabling shell mode', async () => {
+      props.shellModeActive = true;
+
+      const { stdin, unmount } = render(<InputPrompt {...props} />);
+      await wait();
+
+      stdin.write('\x1B');
+      await wait();
+
+      expect(props.setShellModeActive).toHaveBeenCalledWith(false);
+      unmount();
+    });
+
+    it('should handle ESC when completion suggestions are showing', async () => {
+      mockedUseCommandCompletion.mockReturnValue({
+        ...mockCommandCompletion,
+        showSuggestions: true,
+        suggestions: [{ label: 'suggestion', value: 'suggestion' }],
+      });
+
+      const { stdin, unmount } = render(<InputPrompt {...props} />);
+      await wait();
+
+      stdin.write('\x1B');
+      await wait();
+
+      expect(mockCommandCompletion.resetCompletionState).toHaveBeenCalled();
+      unmount();
+    });
+
+    it('should not call onEscapePromptChange when not provided', async () => {
+      props.onEscapePromptChange = undefined;
+      props.buffer.setText('some text');
+
+      const { stdin, unmount } = render(<InputPrompt {...props} />);
+      await wait();
+
+      stdin.write('\x1B');
+      await wait();
+
+      unmount();
+    });
+
+    it('should not interfere with existing keyboard shortcuts', async () => {
+      const { stdin, unmount } = render(<InputPrompt {...props} />);
+      await wait();
+
+      stdin.write('\x0C');
+      await wait();
+
+      expect(props.onClearScreen).toHaveBeenCalled();
+
+      stdin.write('\x01');
+      await wait();
+
+      expect(props.buffer.move).toHaveBeenCalledWith('home');
+      unmount();
+    });
+  });
+
   describe('reverse search', () => {
     beforeEach(async () => {
       props.shellModeActive = true;
diff --git a/packages/cli/src/ui/components/InputPrompt.tsx b/packages/cli/src/ui/components/InputPrompt.tsx
index 78b3b96b..7eb1905d 100644
--- a/packages/cli/src/ui/components/InputPrompt.tsx
+++ b/packages/cli/src/ui/components/InputPrompt.tsx
@@ -4,7 +4,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import React, { useCallback, useEffect, useState } from 'react';
+import React, { useCallback, useEffect, useState, useRef } from 'react';
 import { Box, Text } from 'ink';
 import { theme } from '../semantic-colors.js';
 import { SuggestionsDisplay } from './SuggestionsDisplay.js';
@@ -41,6 +41,7 @@ export interface InputPromptProps {
   suggestionsWidth: number;
   shellModeActive: boolean;
   setShellModeActive: (value: boolean) => void;
+  onEscapePromptChange?: (showPrompt: boolean) => void;
   vimHandleInput?: (key: Key) => boolean;
 }
 
@@ -58,9 +59,13 @@ export const InputPrompt: React.FC<InputPromptProps> = ({
   suggestionsWidth,
   shellModeActive,
   setShellModeActive,
+  onEscapePromptChange,
   vimHandleInput,
 }) => {
   const [justNavigatedHistory, setJustNavigatedHistory] = useState(false);
+  const [escPressCount, setEscPressCount] = useState(0);
+  const [showEscapePrompt, setShowEscapePrompt] = useState(false);
+  const escapeTimerRef = useRef<NodeJS.Timeout | null>(null);
 
   const [dirs, setDirs] = useState<readonly string[]>(
     config.getWorkspaceContext().getDirectories(),
@@ -98,6 +103,32 @@ export const InputPrompt: React.FC<InputPromptProps> = ({
   const resetReverseSearchCompletionState =
     reverseSearchCompletion.resetCompletionState;
 
+  const resetEscapeState = useCallback(() => {
+    if (escapeTimerRef.current) {
+      clearTimeout(escapeTimerRef.current);
+      escapeTimerRef.current = null;
+    }
+    setEscPressCount(0);
+    setShowEscapePrompt(false);
+  }, []);
+
+  // Notify parent component about escape prompt state changes
+  useEffect(() => {
+    if (onEscapePromptChange) {
+      onEscapePromptChange(showEscapePrompt);
+    }
+  }, [showEscapePrompt, onEscapePromptChange]);
+
+  // Clear escape prompt timer on unmount
+  useEffect(
+    () => () => {
+      if (escapeTimerRef.current) {
+        clearTimeout(escapeTimerRef.current);
+      }
+    },
+    [],
+  );
+
   const handleSubmitAndClear = useCallback(
     (submittedValue: string) => {
       if (shellModeActive) {
@@ -212,6 +243,13 @@ export const InputPrompt: React.FC<InputPromptProps> = ({
         return;
       }
 
+      // Reset ESC count and hide prompt on any non-ESC key
+      if (key.name !== 'escape') {
+        if (escPressCount > 0 || showEscapePrompt) {
+          resetEscapeState();
+        }
+      }
+
       if (
         key.sequence === '!' &&
         buffer.text === '' &&
@@ -237,13 +275,36 @@ export const InputPrompt: React.FC<InputPromptProps> = ({
         }
         if (shellModeActive) {
           setShellModeActive(false);
+          resetEscapeState();
           return;
         }
 
         if (completion.showSuggestions) {
           completion.resetCompletionState();
+          resetEscapeState();
           return;
         }
+
+        // Handle double ESC for clearing input
+        if (escPressCount === 0) {
+          if (buffer.text === '') {
+            return;
+          }
+          setEscPressCount(1);
+          setShowEscapePrompt(true);
+          if (escapeTimerRef.current) {
+            clearTimeout(escapeTimerRef.current);
+          }
+          escapeTimerRef.current = setTimeout(() => {
+            resetEscapeState();
+          }, 500);
+        } else {
+          // clear input and immediately reset state
+          buffer.setText('');
+          resetCompletionState();
+          resetEscapeState();
+        }
+        return;
       }
 
       if (shellModeActive && keyMatchers[Command.REVERSE_SEARCH](key)) {
@@ -418,7 +479,6 @@ export const InputPrompt: React.FC<InputPromptProps> = ({
         if (buffer.text.length > 0) {
           buffer.setText('');
           resetCompletionState();
-          return;
         }
         return;
       }
@@ -461,6 +521,9 @@ export const InputPrompt: React.FC<InputPromptProps> = ({
       reverseSearchCompletion,
       handleClipboardImage,
       resetCompletionState,
+      escPressCount,
+      showEscapePrompt,
+      resetEscapeState,
       vimHandleInput,
       reverseSearchActive,
       textBeforeReverseSearch,

From c632ec8b03ac5b459da9ccb041b9fca19252f69b Mon Sep 17 00:00:00 2001
From: Lee Won Jun <dldnjs1013@gmail.com>
Date: Sun, 10 Aug 2025 07:28:28 +0900
Subject: [PATCH 079/107] [#5356] Minor fix: Remove duplicate binding and add
 complete navigation command (#5884)

Co-authored-by: Jacob Richman <jacob314@gmail.com>
---
 packages/cli/src/config/keyBindings.ts        | 15 +++---
 .../cli/src/ui/components/InputPrompt.tsx     | 10 +---
 packages/cli/src/ui/keyMatchers.test.ts       | 51 +++++++++----------
 3 files changed, 34 insertions(+), 42 deletions(-)

diff --git a/packages/cli/src/config/keyBindings.ts b/packages/cli/src/config/keyBindings.ts
index f6ba52e2..6f4a21a2 100644
--- a/packages/cli/src/config/keyBindings.ts
+++ b/packages/cli/src/config/keyBindings.ts
@@ -32,6 +32,8 @@ export enum Command {
 
   // Auto-completion
   ACCEPT_SUGGESTION = 'acceptSuggestion',
+  COMPLETION_UP = 'completionUp',
+  COMPLETION_DOWN = 'completionDown',
 
   // Text input
   SUBMIT = 'submit',
@@ -121,6 +123,9 @@ export const defaultKeyBindings: KeyBindingConfig = {
   // Auto-completion
   // Original: key.name === 'tab' || (key.name === 'return' && !key.ctrl)
   [Command.ACCEPT_SUGGESTION]: [{ key: 'tab' }, { key: 'return', ctrl: false }],
+  // Completion navigation (arrow or Ctrl+P/N)
+  [Command.COMPLETION_UP]: [{ key: 'up' }, { key: 'p', ctrl: true }],
+  [Command.COMPLETION_DOWN]: [{ key: 'down' }, { key: 'n', ctrl: true }],
 
   // Text input
   // Original: key.name === 'return' && !key.ctrl && !key.meta && !key.paste
@@ -157,15 +162,9 @@ export const defaultKeyBindings: KeyBindingConfig = {
   // Original: key.ctrl && key.name === 'e'
   [Command.TOGGLE_IDE_CONTEXT_DETAIL]: [{ key: 'e', ctrl: true }],
   // Original: key.ctrl && (key.name === 'c' || key.name === 'C')
-  [Command.QUIT]: [
-    { key: 'c', ctrl: true },
-    { key: 'C', ctrl: true },
-  ],
+  [Command.QUIT]: [{ key: 'c', ctrl: true }],
   // Original: key.ctrl && (key.name === 'd' || key.name === 'D')
-  [Command.EXIT]: [
-    { key: 'd', ctrl: true },
-    { key: 'D', ctrl: true },
-  ],
+  [Command.EXIT]: [{ key: 'd', ctrl: true }],
   // Original: key.ctrl && key.name === 's'
   [Command.SHOW_MORE_LINES]: [{ key: 's', ctrl: true }],
 
diff --git a/packages/cli/src/ui/components/InputPrompt.tsx b/packages/cli/src/ui/components/InputPrompt.tsx
index 7eb1905d..f53d255f 100644
--- a/packages/cli/src/ui/components/InputPrompt.tsx
+++ b/packages/cli/src/ui/components/InputPrompt.tsx
@@ -373,17 +373,11 @@ export const InputPrompt: React.FC<InputPromptProps> = ({
 
       if (completion.showSuggestions) {
         if (completion.suggestions.length > 1) {
-          if (
-            keyMatchers[Command.NAVIGATION_UP](key) ||
-            keyMatchers[Command.HISTORY_UP](key)
-          ) {
+          if (keyMatchers[Command.COMPLETION_UP](key)) {
             completion.navigateUp();
             return;
           }
-          if (
-            keyMatchers[Command.NAVIGATION_DOWN](key) ||
-            keyMatchers[Command.HISTORY_DOWN](key)
-          ) {
+          if (keyMatchers[Command.COMPLETION_DOWN](key)) {
             completion.navigateDown();
             return;
           }
diff --git a/packages/cli/src/ui/keyMatchers.test.ts b/packages/cli/src/ui/keyMatchers.test.ts
index 16951e79..9c72f2dd 100644
--- a/packages/cli/src/ui/keyMatchers.test.ts
+++ b/packages/cli/src/ui/keyMatchers.test.ts
@@ -21,7 +21,8 @@ describe('keyMatchers', () => {
   });
 
   // Original hard-coded logic (for comparison)
-  const originalMatchers = {
+  const originalMatchers: Record<Command, (key: Key) => boolean> = {
+    [Command.RETURN]: (key: Key) => key.name === 'return',
     [Command.HOME]: (key: Key) => key.ctrl && key.name === 'a',
     [Command.END]: (key: Key) => key.ctrl && key.name === 'e',
     [Command.KILL_LINE_RIGHT]: (key: Key) => key.ctrl && key.name === 'k',
@@ -34,6 +35,10 @@ describe('keyMatchers', () => {
     [Command.NAVIGATION_DOWN]: (key: Key) => key.name === 'down',
     [Command.ACCEPT_SUGGESTION]: (key: Key) =>
       key.name === 'tab' || (key.name === 'return' && !key.ctrl),
+    [Command.COMPLETION_UP]: (key: Key) =>
+      key.name === 'up' || (key.ctrl && key.name === 'p'),
+    [Command.COMPLETION_DOWN]: (key: Key) =>
+      key.name === 'down' || (key.ctrl && key.name === 'n'),
     [Command.ESCAPE]: (key: Key) => key.name === 'escape',
     [Command.SUBMIT]: (key: Key) =>
       key.name === 'return' && !key.ctrl && !key.meta && !key.paste,
@@ -47,10 +52,8 @@ describe('keyMatchers', () => {
       key.ctrl && key.name === 't',
     [Command.TOGGLE_IDE_CONTEXT_DETAIL]: (key: Key) =>
       key.ctrl && key.name === 'e',
-    [Command.QUIT]: (key: Key) =>
-      key.ctrl && (key.name === 'c' || key.name === 'C'),
-    [Command.EXIT]: (key: Key) =>
-      key.ctrl && (key.name === 'd' || key.name === 'D'),
+    [Command.QUIT]: (key: Key) => key.ctrl && key.name === 'c',
+    [Command.EXIT]: (key: Key) => key.ctrl && key.name === 'd',
     [Command.SHOW_MORE_LINES]: (key: Key) => key.ctrl && key.name === 's',
     [Command.REVERSE_SEARCH]: (key: Key) => key.ctrl && key.name === 'r',
     [Command.SUBMIT_REVERSE_SEARCH]: (key: Key) =>
@@ -62,6 +65,11 @@ describe('keyMatchers', () => {
   // Test data for each command with positive and negative test cases
   const testCases = [
     // Basic bindings
+    {
+      command: Command.RETURN,
+      positive: [createKey('return')],
+      negative: [createKey('r')],
+    },
     {
       command: Command.ESCAPE,
       positive: [createKey('escape'), createKey('escape', { ctrl: true })],
@@ -140,6 +148,16 @@ describe('keyMatchers', () => {
       positive: [createKey('tab'), createKey('return')],
       negative: [createKey('return', { ctrl: true }), createKey('space')],
     },
+    {
+      command: Command.COMPLETION_UP,
+      positive: [createKey('up'), createKey('p', { ctrl: true })],
+      negative: [createKey('p'), createKey('down')],
+    },
+    {
+      command: Command.COMPLETION_DOWN,
+      positive: [createKey('down'), createKey('n', { ctrl: true })],
+      negative: [createKey('n'), createKey('up')],
+    },
 
     // Text input
     {
@@ -194,18 +212,12 @@ describe('keyMatchers', () => {
     },
     {
       command: Command.QUIT,
-      positive: [
-        createKey('c', { ctrl: true }),
-        createKey('C', { ctrl: true }),
-      ],
+      positive: [createKey('c', { ctrl: true })],
       negative: [createKey('c'), createKey('d', { ctrl: true })],
     },
     {
       command: Command.EXIT,
-      positive: [
-        createKey('d', { ctrl: true }),
-        createKey('D', { ctrl: true }),
-      ],
+      positive: [createKey('d', { ctrl: true })],
       negative: [createKey('d'), createKey('c', { ctrl: true })],
     },
     {
@@ -321,18 +333,5 @@ describe('keyMatchers', () => {
         false,
       );
     });
-
-    it('should handle case sensitivity', () => {
-      const config: KeyBindingConfig = {
-        ...defaultKeyBindings,
-        [Command.QUIT]: [{ key: 'Q', ctrl: true }],
-      };
-
-      const matchers = createKeyMatchers(config);
-      expect(matchers[Command.QUIT](createKey('Q', { ctrl: true }))).toBe(true);
-      expect(matchers[Command.QUIT](createKey('q', { ctrl: true }))).toBe(
-        false,
-      );
-    });
   });
 });

From 8a9a9275440e3681e9be73d741a5aba429ae501f Mon Sep 17 00:00:00 2001
From: Ali Al Jufairi <ali.redha.ali@gmail.com>
Date: Sun, 10 Aug 2025 09:04:52 +0900
Subject: [PATCH 080/107] feat(ui): add /settings command and UI panel (#4738)

Co-authored-by: Jacob Richman <jacob314@gmail.com>
---
 packages/cli/src/config/settings.ts           |  91 +-
 .../cli/src/config/settingsSchema.test.ts     | 253 ++++++
 packages/cli/src/config/settingsSchema.ts     | 516 +++++++++++
 .../cli/src/services/BuiltinCommandLoader.ts  |   2 +
 packages/cli/src/ui/App.tsx                   |  16 +-
 .../src/ui/commands/settingsCommand.test.ts   |  36 +
 .../cli/src/ui/commands/settingsCommand.ts    |  17 +
 packages/cli/src/ui/commands/types.ts         |   3 +-
 .../src/ui/components/SettingsDialog.test.tsx | 831 ++++++++++++++++++
 .../cli/src/ui/components/SettingsDialog.tsx  | 465 ++++++++++
 .../cli/src/ui/components/ThemeDialog.tsx     |  30 +-
 .../ui/hooks/slashCommandProcessor.test.ts    |   4 +
 .../cli/src/ui/hooks/slashCommandProcessor.ts |   7 +
 .../cli/src/ui/hooks/useSettingsCommand.ts    |  25 +
 packages/cli/src/utils/dialogScopeUtils.ts    |  64 ++
 packages/cli/src/utils/settingsUtils.test.ts  | 797 +++++++++++++++++
 packages/cli/src/utils/settingsUtils.ts       | 473 ++++++++++
 17 files changed, 3521 insertions(+), 109 deletions(-)
 create mode 100644 packages/cli/src/config/settingsSchema.test.ts
 create mode 100644 packages/cli/src/config/settingsSchema.ts
 create mode 100644 packages/cli/src/ui/commands/settingsCommand.test.ts
 create mode 100644 packages/cli/src/ui/commands/settingsCommand.ts
 create mode 100644 packages/cli/src/ui/components/SettingsDialog.test.tsx
 create mode 100644 packages/cli/src/ui/components/SettingsDialog.tsx
 create mode 100644 packages/cli/src/ui/hooks/useSettingsCommand.ts
 create mode 100644 packages/cli/src/utils/dialogScopeUtils.ts
 create mode 100644 packages/cli/src/utils/settingsUtils.test.ts
 create mode 100644 packages/cli/src/utils/settingsUtils.ts

diff --git a/packages/cli/src/config/settings.ts b/packages/cli/src/config/settings.ts
index 3c4270d7..36fd50f1 100644
--- a/packages/cli/src/config/settings.ts
+++ b/packages/cli/src/config/settings.ts
@@ -9,18 +9,15 @@ import * as path from 'path';
 import { homedir, platform } from 'os';
 import * as dotenv from 'dotenv';
 import {
-  MCPServerConfig,
   GEMINI_CONFIG_DIR as GEMINI_DIR,
   getErrorMessage,
-  BugCommandSettings,
-  ChatCompressionSettings,
-  TelemetrySettings,
-  AuthType,
 } from '@google/gemini-cli-core';
 import stripJsonComments from 'strip-json-comments';
 import { DefaultLight } from '../ui/themes/default-light.js';
 import { DefaultDark } from '../ui/themes/default.js';
-import { CustomTheme } from '../ui/themes/theme.js';
+import { Settings, MemoryImportFormat } from './settingsSchema.js';
+
+export type { Settings, MemoryImportFormat };
 
 export const SETTINGS_DIRECTORY_NAME = '.gemini';
 export const USER_SETTINGS_DIR = path.join(homedir(), SETTINGS_DIRECTORY_NAME);
@@ -44,7 +41,7 @@ export function getWorkspaceSettingsPath(workspaceDir: string): string {
   return path.join(workspaceDir, SETTINGS_DIRECTORY_NAME, 'settings.json');
 }
 
-export type DnsResolutionOrder = 'ipv4first' | 'verbatim';
+export type { DnsResolutionOrder } from './settingsSchema.js';
 
 export enum SettingScope {
   User = 'User',
@@ -64,86 +61,6 @@ export interface AccessibilitySettings {
   disableLoadingPhrases?: boolean;
 }
 
-export interface Settings {
-  theme?: string;
-  customThemes?: Record<string, CustomTheme>;
-  selectedAuthType?: AuthType;
-  useExternalAuth?: boolean;
-  sandbox?: boolean | string;
-  coreTools?: string[];
-  excludeTools?: string[];
-  toolDiscoveryCommand?: string;
-  toolCallCommand?: string;
-  mcpServerCommand?: string;
-  mcpServers?: Record<string, MCPServerConfig>;
-  allowMCPServers?: string[];
-  excludeMCPServers?: string[];
-  showMemoryUsage?: boolean;
-  contextFileName?: string | string[];
-  accessibility?: AccessibilitySettings;
-  telemetry?: TelemetrySettings;
-  usageStatisticsEnabled?: boolean;
-  preferredEditor?: string;
-  bugCommand?: BugCommandSettings;
-  checkpointing?: CheckpointingSettings;
-  autoConfigureMaxOldSpaceSize?: boolean;
-  /** The model name to use (e.g 'gemini-9.0-pro') */
-  model?: string;
-
-  // Git-aware file filtering settings
-  fileFiltering?: {
-    respectGitIgnore?: boolean;
-    respectGeminiIgnore?: boolean;
-    enableRecursiveFileSearch?: boolean;
-  };
-
-  hideWindowTitle?: boolean;
-
-  hideTips?: boolean;
-  hideBanner?: boolean;
-
-  // Setting for setting maximum number of user/model/tool turns in a session.
-  maxSessionTurns?: number;
-
-  // A map of tool names to their summarization settings.
-  summarizeToolOutput?: Record<string, SummarizeToolOutputSettings>;
-
-  vimMode?: boolean;
-  memoryImportFormat?: 'tree' | 'flat';
-
-  // Flag to be removed post-launch.
-  ideModeFeature?: boolean;
-  /// IDE mode setting configured via slash command toggle.
-  ideMode?: boolean;
-
-  // Flag to be removed post-launch.
-  folderTrustFeature?: boolean;
-  // Setting to track whether Folder trust is enabled.
-  folderTrust?: boolean;
-
-  // Setting to track if the user has seen the IDE integration nudge.
-  hasSeenIdeIntegrationNudge?: boolean;
-
-  // Setting for disabling auto-update.
-  disableAutoUpdate?: boolean;
-
-  // Setting for disabling the update nag message.
-  disableUpdateNag?: boolean;
-
-  memoryDiscoveryMaxDirs?: number;
-
-  // Environment variables to exclude from project .env files
-  excludedProjectEnvVars?: string[];
-  dnsResolutionOrder?: DnsResolutionOrder;
-
-  includeDirectories?: string[];
-
-  loadMemoryFromIncludeDirectories?: boolean;
-
-  chatCompression?: ChatCompressionSettings;
-  showLineNumbers?: boolean;
-}
-
 export interface SettingsError {
   message: string;
   path: string;
diff --git a/packages/cli/src/config/settingsSchema.test.ts b/packages/cli/src/config/settingsSchema.test.ts
new file mode 100644
index 00000000..ab820ee1
--- /dev/null
+++ b/packages/cli/src/config/settingsSchema.test.ts
@@ -0,0 +1,253 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { describe, it, expect } from 'vitest';
+import { SETTINGS_SCHEMA, Settings } from './settingsSchema.js';
+
+describe('SettingsSchema', () => {
+  describe('SETTINGS_SCHEMA', () => {
+    it('should contain all expected top-level settings', () => {
+      const expectedSettings = [
+        'theme',
+        'customThemes',
+        'showMemoryUsage',
+        'usageStatisticsEnabled',
+        'autoConfigureMaxOldSpaceSize',
+        'preferredEditor',
+        'maxSessionTurns',
+        'memoryImportFormat',
+        'memoryDiscoveryMaxDirs',
+        'contextFileName',
+        'vimMode',
+        'ideMode',
+        'accessibility',
+        'checkpointing',
+        'fileFiltering',
+        'disableAutoUpdate',
+        'hideWindowTitle',
+        'hideTips',
+        'hideBanner',
+        'selectedAuthType',
+        'useExternalAuth',
+        'sandbox',
+        'coreTools',
+        'excludeTools',
+        'toolDiscoveryCommand',
+        'toolCallCommand',
+        'mcpServerCommand',
+        'mcpServers',
+        'allowMCPServers',
+        'excludeMCPServers',
+        'telemetry',
+        'bugCommand',
+        'summarizeToolOutput',
+        'ideModeFeature',
+        'dnsResolutionOrder',
+        'excludedProjectEnvVars',
+        'disableUpdateNag',
+        'includeDirectories',
+        'loadMemoryFromIncludeDirectories',
+        'model',
+        'hasSeenIdeIntegrationNudge',
+        'folderTrustFeature',
+      ];
+
+      expectedSettings.forEach((setting) => {
+        expect(
+          SETTINGS_SCHEMA[setting as keyof typeof SETTINGS_SCHEMA],
+        ).toBeDefined();
+      });
+    });
+
+    it('should have correct structure for each setting', () => {
+      Object.entries(SETTINGS_SCHEMA).forEach(([_key, definition]) => {
+        expect(definition).toHaveProperty('type');
+        expect(definition).toHaveProperty('label');
+        expect(definition).toHaveProperty('category');
+        expect(definition).toHaveProperty('requiresRestart');
+        expect(definition).toHaveProperty('default');
+        expect(typeof definition.type).toBe('string');
+        expect(typeof definition.label).toBe('string');
+        expect(typeof definition.category).toBe('string');
+        expect(typeof definition.requiresRestart).toBe('boolean');
+      });
+    });
+
+    it('should have correct nested setting structure', () => {
+      const nestedSettings = [
+        'accessibility',
+        'checkpointing',
+        'fileFiltering',
+      ];
+
+      nestedSettings.forEach((setting) => {
+        const definition = SETTINGS_SCHEMA[
+          setting as keyof typeof SETTINGS_SCHEMA
+        ] as (typeof SETTINGS_SCHEMA)[keyof typeof SETTINGS_SCHEMA] & {
+          properties: unknown;
+        };
+        expect(definition.type).toBe('object');
+        expect(definition.properties).toBeDefined();
+        expect(typeof definition.properties).toBe('object');
+      });
+    });
+
+    it('should have accessibility nested properties', () => {
+      expect(
+        SETTINGS_SCHEMA.accessibility.properties?.disableLoadingPhrases,
+      ).toBeDefined();
+      expect(
+        SETTINGS_SCHEMA.accessibility.properties?.disableLoadingPhrases.type,
+      ).toBe('boolean');
+    });
+
+    it('should have checkpointing nested properties', () => {
+      expect(SETTINGS_SCHEMA.checkpointing.properties?.enabled).toBeDefined();
+      expect(SETTINGS_SCHEMA.checkpointing.properties?.enabled.type).toBe(
+        'boolean',
+      );
+    });
+
+    it('should have fileFiltering nested properties', () => {
+      expect(
+        SETTINGS_SCHEMA.fileFiltering.properties?.respectGitIgnore,
+      ).toBeDefined();
+      expect(
+        SETTINGS_SCHEMA.fileFiltering.properties?.respectGeminiIgnore,
+      ).toBeDefined();
+      expect(
+        SETTINGS_SCHEMA.fileFiltering.properties?.enableRecursiveFileSearch,
+      ).toBeDefined();
+    });
+
+    it('should have unique categories', () => {
+      const categories = new Set();
+
+      // Collect categories from top-level settings
+      Object.values(SETTINGS_SCHEMA).forEach((definition) => {
+        categories.add(definition.category);
+        // Also collect from nested properties
+        const defWithProps = definition as typeof definition & {
+          properties?: Record<string, unknown>;
+        };
+        if (defWithProps.properties) {
+          Object.values(defWithProps.properties).forEach(
+            (nestedDef: unknown) => {
+              const nestedDefTyped = nestedDef as { category?: string };
+              if (nestedDefTyped.category) {
+                categories.add(nestedDefTyped.category);
+              }
+            },
+          );
+        }
+      });
+
+      expect(categories.size).toBeGreaterThan(0);
+      expect(categories).toContain('General');
+      expect(categories).toContain('UI');
+      expect(categories).toContain('Mode');
+      expect(categories).toContain('Updates');
+      expect(categories).toContain('Accessibility');
+      expect(categories).toContain('Checkpointing');
+      expect(categories).toContain('File Filtering');
+      expect(categories).toContain('Advanced');
+    });
+
+    it('should have consistent default values for boolean settings', () => {
+      const checkBooleanDefaults = (schema: Record<string, unknown>) => {
+        Object.entries(schema).forEach(
+          ([_key, definition]: [string, unknown]) => {
+            const def = definition as {
+              type?: string;
+              default?: unknown;
+              properties?: Record<string, unknown>;
+            };
+            if (def.type === 'boolean') {
+              // Boolean settings can have boolean or undefined defaults (for optional settings)
+              expect(['boolean', 'undefined']).toContain(typeof def.default);
+            }
+            if (def.properties) {
+              checkBooleanDefaults(def.properties);
+            }
+          },
+        );
+      };
+
+      checkBooleanDefaults(SETTINGS_SCHEMA as Record<string, unknown>);
+    });
+
+    it('should have showInDialog property configured', () => {
+      // Check that user-facing settings are marked for dialog display
+      expect(SETTINGS_SCHEMA.showMemoryUsage.showInDialog).toBe(true);
+      expect(SETTINGS_SCHEMA.vimMode.showInDialog).toBe(true);
+      expect(SETTINGS_SCHEMA.ideMode.showInDialog).toBe(true);
+      expect(SETTINGS_SCHEMA.disableAutoUpdate.showInDialog).toBe(true);
+      expect(SETTINGS_SCHEMA.hideWindowTitle.showInDialog).toBe(true);
+      expect(SETTINGS_SCHEMA.hideTips.showInDialog).toBe(true);
+      expect(SETTINGS_SCHEMA.hideBanner.showInDialog).toBe(true);
+      expect(SETTINGS_SCHEMA.usageStatisticsEnabled.showInDialog).toBe(true);
+
+      // Check that advanced settings are hidden from dialog
+      expect(SETTINGS_SCHEMA.selectedAuthType.showInDialog).toBe(false);
+      expect(SETTINGS_SCHEMA.coreTools.showInDialog).toBe(false);
+      expect(SETTINGS_SCHEMA.mcpServers.showInDialog).toBe(false);
+      expect(SETTINGS_SCHEMA.telemetry.showInDialog).toBe(false);
+
+      // Check that some settings are appropriately hidden
+      expect(SETTINGS_SCHEMA.theme.showInDialog).toBe(false); // Changed to false
+      expect(SETTINGS_SCHEMA.customThemes.showInDialog).toBe(false); // Managed via theme editor
+      expect(SETTINGS_SCHEMA.checkpointing.showInDialog).toBe(false); // Experimental feature
+      expect(SETTINGS_SCHEMA.accessibility.showInDialog).toBe(false); // Changed to false
+      expect(SETTINGS_SCHEMA.fileFiltering.showInDialog).toBe(false); // Changed to false
+      expect(SETTINGS_SCHEMA.preferredEditor.showInDialog).toBe(false); // Changed to false
+      expect(SETTINGS_SCHEMA.autoConfigureMaxOldSpaceSize.showInDialog).toBe(
+        true,
+      );
+    });
+
+    it('should infer Settings type correctly', () => {
+      // This test ensures that the Settings type is properly inferred from the schema
+      const settings: Settings = {
+        theme: 'dark',
+        includeDirectories: ['/path/to/dir'],
+        loadMemoryFromIncludeDirectories: true,
+      };
+
+      // TypeScript should not complain about these properties
+      expect(settings.theme).toBe('dark');
+      expect(settings.includeDirectories).toEqual(['/path/to/dir']);
+      expect(settings.loadMemoryFromIncludeDirectories).toBe(true);
+    });
+
+    it('should have includeDirectories setting in schema', () => {
+      expect(SETTINGS_SCHEMA.includeDirectories).toBeDefined();
+      expect(SETTINGS_SCHEMA.includeDirectories.type).toBe('array');
+      expect(SETTINGS_SCHEMA.includeDirectories.category).toBe('General');
+      expect(SETTINGS_SCHEMA.includeDirectories.default).toEqual([]);
+    });
+
+    it('should have loadMemoryFromIncludeDirectories setting in schema', () => {
+      expect(SETTINGS_SCHEMA.loadMemoryFromIncludeDirectories).toBeDefined();
+      expect(SETTINGS_SCHEMA.loadMemoryFromIncludeDirectories.type).toBe(
+        'boolean',
+      );
+      expect(SETTINGS_SCHEMA.loadMemoryFromIncludeDirectories.category).toBe(
+        'General',
+      );
+      expect(SETTINGS_SCHEMA.loadMemoryFromIncludeDirectories.default).toBe(
+        false,
+      );
+    });
+
+    it('should have folderTrustFeature setting in schema', () => {
+      expect(SETTINGS_SCHEMA.folderTrustFeature).toBeDefined();
+      expect(SETTINGS_SCHEMA.folderTrustFeature.type).toBe('boolean');
+      expect(SETTINGS_SCHEMA.folderTrustFeature.category).toBe('General');
+      expect(SETTINGS_SCHEMA.folderTrustFeature.default).toBe(false);
+      expect(SETTINGS_SCHEMA.folderTrustFeature.showInDialog).toBe(true);
+    });
+  });
+});
diff --git a/packages/cli/src/config/settingsSchema.ts b/packages/cli/src/config/settingsSchema.ts
new file mode 100644
index 00000000..dc2582ec
--- /dev/null
+++ b/packages/cli/src/config/settingsSchema.ts
@@ -0,0 +1,516 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import {
+  MCPServerConfig,
+  BugCommandSettings,
+  TelemetrySettings,
+  AuthType,
+  ChatCompressionSettings,
+} from '@google/gemini-cli-core';
+import { CustomTheme } from '../ui/themes/theme.js';
+
+export interface SettingDefinition {
+  type: 'boolean' | 'string' | 'number' | 'array' | 'object';
+  label: string;
+  category: string;
+  requiresRestart: boolean;
+  default: boolean | string | number | string[] | object | undefined;
+  description?: string;
+  parentKey?: string;
+  childKey?: string;
+  key?: string;
+  properties?: SettingsSchema;
+  showInDialog?: boolean;
+}
+
+export interface SettingsSchema {
+  [key: string]: SettingDefinition;
+}
+
+export type MemoryImportFormat = 'tree' | 'flat';
+export type DnsResolutionOrder = 'ipv4first' | 'verbatim';
+
+/**
+ * The canonical schema for all settings.
+ * The structure of this object defines the structure of the `Settings` type.
+ * `as const` is crucial for TypeScript to infer the most specific types possible.
+ */
+export const SETTINGS_SCHEMA = {
+  // UI Settings
+  theme: {
+    type: 'string',
+    label: 'Theme',
+    category: 'UI',
+    requiresRestart: false,
+    default: undefined as string | undefined,
+    description: 'The color theme for the UI.',
+    showInDialog: false,
+  },
+  customThemes: {
+    type: 'object',
+    label: 'Custom Themes',
+    category: 'UI',
+    requiresRestart: false,
+    default: {} as Record<string, CustomTheme>,
+    description: 'Custom theme definitions.',
+    showInDialog: false,
+  },
+  hideWindowTitle: {
+    type: 'boolean',
+    label: 'Hide Window Title',
+    category: 'UI',
+    requiresRestart: true,
+    default: false,
+    description: 'Hide the window title bar',
+    showInDialog: true,
+  },
+  hideTips: {
+    type: 'boolean',
+    label: 'Hide Tips',
+    category: 'UI',
+    requiresRestart: false,
+    default: false,
+    description: 'Hide helpful tips in the UI',
+    showInDialog: true,
+  },
+  hideBanner: {
+    type: 'boolean',
+    label: 'Hide Banner',
+    category: 'UI',
+    requiresRestart: false,
+    default: false,
+    description: 'Hide the application banner',
+    showInDialog: true,
+  },
+  showMemoryUsage: {
+    type: 'boolean',
+    label: 'Show Memory Usage',
+    category: 'UI',
+    requiresRestart: false,
+    default: false,
+    description: 'Display memory usage information in the UI',
+    showInDialog: true,
+  },
+
+  usageStatisticsEnabled: {
+    type: 'boolean',
+    label: 'Enable Usage Statistics',
+    category: 'General',
+    requiresRestart: true,
+    default: false,
+    description: 'Enable collection of usage statistics',
+    showInDialog: true,
+  },
+  autoConfigureMaxOldSpaceSize: {
+    type: 'boolean',
+    label: 'Auto Configure Max Old Space Size',
+    category: 'General',
+    requiresRestart: true,
+    default: false,
+    description: 'Automatically configure Node.js memory limits',
+    showInDialog: true,
+  },
+  preferredEditor: {
+    type: 'string',
+    label: 'Preferred Editor',
+    category: 'General',
+    requiresRestart: false,
+    default: undefined as string | undefined,
+    description: 'The preferred editor to open files in.',
+    showInDialog: false,
+  },
+  maxSessionTurns: {
+    type: 'number',
+    label: 'Max Session Turns',
+    category: 'General',
+    requiresRestart: false,
+    default: undefined as number | undefined,
+    description:
+      'Maximum number of user/model/tool turns to keep in a session.',
+    showInDialog: false,
+  },
+  memoryImportFormat: {
+    type: 'string',
+    label: 'Memory Import Format',
+    category: 'General',
+    requiresRestart: false,
+    default: undefined as MemoryImportFormat | undefined,
+    description: 'The format to use when importing memory.',
+    showInDialog: false,
+  },
+  memoryDiscoveryMaxDirs: {
+    type: 'number',
+    label: 'Memory Discovery Max Dirs',
+    category: 'General',
+    requiresRestart: false,
+    default: undefined as number | undefined,
+    description: 'Maximum number of directories to search for memory.',
+    showInDialog: false,
+  },
+  contextFileName: {
+    type: 'object',
+    label: 'Context File Name',
+    category: 'General',
+    requiresRestart: false,
+    default: undefined as string | string[] | undefined,
+    description: 'The name of the context file.',
+    showInDialog: false,
+  },
+  vimMode: {
+    type: 'boolean',
+    label: 'Vim Mode',
+    category: 'Mode',
+    requiresRestart: false,
+    default: false,
+    description: 'Enable Vim keybindings',
+    showInDialog: true,
+  },
+  ideMode: {
+    type: 'boolean',
+    label: 'IDE Mode',
+    category: 'Mode',
+    requiresRestart: true,
+    default: false,
+    description: 'Enable IDE integration mode',
+    showInDialog: true,
+  },
+
+  accessibility: {
+    type: 'object',
+    label: 'Accessibility',
+    category: 'Accessibility',
+    requiresRestart: true,
+    default: {},
+    description: 'Accessibility settings.',
+    showInDialog: false,
+    properties: {
+      disableLoadingPhrases: {
+        type: 'boolean',
+        label: 'Disable Loading Phrases',
+        category: 'Accessibility',
+        requiresRestart: true,
+        default: false,
+        description: 'Disable loading phrases for accessibility',
+        showInDialog: true,
+      },
+    },
+  },
+  checkpointing: {
+    type: 'object',
+    label: 'Checkpointing',
+    category: 'Checkpointing',
+    requiresRestart: true,
+    default: {},
+    description: 'Session checkpointing settings.',
+    showInDialog: false,
+    properties: {
+      enabled: {
+        type: 'boolean',
+        label: 'Enable Checkpointing',
+        category: 'Checkpointing',
+        requiresRestart: true,
+        default: false,
+        description: 'Enable session checkpointing for recovery',
+        showInDialog: false,
+      },
+    },
+  },
+  fileFiltering: {
+    type: 'object',
+    label: 'File Filtering',
+    category: 'File Filtering',
+    requiresRestart: true,
+    default: {},
+    description: 'Settings for git-aware file filtering.',
+    showInDialog: false,
+    properties: {
+      respectGitIgnore: {
+        type: 'boolean',
+        label: 'Respect .gitignore',
+        category: 'File Filtering',
+        requiresRestart: true,
+        default: true,
+        description: 'Respect .gitignore files when searching',
+        showInDialog: true,
+      },
+      respectGeminiIgnore: {
+        type: 'boolean',
+        label: 'Respect .geminiignore',
+        category: 'File Filtering',
+        requiresRestart: true,
+        default: true,
+        description: 'Respect .geminiignore files when searching',
+        showInDialog: true,
+      },
+      enableRecursiveFileSearch: {
+        type: 'boolean',
+        label: 'Enable Recursive File Search',
+        category: 'File Filtering',
+        requiresRestart: true,
+        default: true,
+        description: 'Enable recursive file search functionality',
+        showInDialog: true,
+      },
+    },
+  },
+
+  disableAutoUpdate: {
+    type: 'boolean',
+    label: 'Disable Auto Update',
+    category: 'Updates',
+    requiresRestart: false,
+    default: false,
+    description: 'Disable automatic updates',
+    showInDialog: true,
+  },
+
+  selectedAuthType: {
+    type: 'string',
+    label: 'Selected Auth Type',
+    category: 'Advanced',
+    requiresRestart: true,
+    default: undefined as AuthType | undefined,
+    description: 'The currently selected authentication type.',
+    showInDialog: false,
+  },
+  useExternalAuth: {
+    type: 'boolean',
+    label: 'Use External Auth',
+    category: 'Advanced',
+    requiresRestart: true,
+    default: undefined as boolean | undefined,
+    description: 'Whether to use an external authentication flow.',
+    showInDialog: false,
+  },
+  sandbox: {
+    type: 'object',
+    label: 'Sandbox',
+    category: 'Advanced',
+    requiresRestart: true,
+    default: undefined as boolean | string | undefined,
+    description:
+      'Sandbox execution environment (can be a boolean or a path string).',
+    showInDialog: false,
+  },
+  coreTools: {
+    type: 'array',
+    label: 'Core Tools',
+    category: 'Advanced',
+    requiresRestart: true,
+    default: undefined as string[] | undefined,
+    description: 'Paths to core tool definitions.',
+    showInDialog: false,
+  },
+  excludeTools: {
+    type: 'array',
+    label: 'Exclude Tools',
+    category: 'Advanced',
+    requiresRestart: true,
+    default: undefined as string[] | undefined,
+    description: 'Tool names to exclude from discovery.',
+    showInDialog: false,
+  },
+  toolDiscoveryCommand: {
+    type: 'string',
+    label: 'Tool Discovery Command',
+    category: 'Advanced',
+    requiresRestart: true,
+    default: undefined as string | undefined,
+    description: 'Command to run for tool discovery.',
+    showInDialog: false,
+  },
+  toolCallCommand: {
+    type: 'string',
+    label: 'Tool Call Command',
+    category: 'Advanced',
+    requiresRestart: true,
+    default: undefined as string | undefined,
+    description: 'Command to run for tool calls.',
+    showInDialog: false,
+  },
+  mcpServerCommand: {
+    type: 'string',
+    label: 'MCP Server Command',
+    category: 'Advanced',
+    requiresRestart: true,
+    default: undefined as string | undefined,
+    description: 'Command to start an MCP server.',
+    showInDialog: false,
+  },
+  mcpServers: {
+    type: 'object',
+    label: 'MCP Servers',
+    category: 'Advanced',
+    requiresRestart: true,
+    default: {} as Record<string, MCPServerConfig>,
+    description: 'Configuration for MCP servers.',
+    showInDialog: false,
+  },
+  allowMCPServers: {
+    type: 'array',
+    label: 'Allow MCP Servers',
+    category: 'Advanced',
+    requiresRestart: true,
+    default: undefined as string[] | undefined,
+    description: 'A whitelist of MCP servers to allow.',
+    showInDialog: false,
+  },
+  excludeMCPServers: {
+    type: 'array',
+    label: 'Exclude MCP Servers',
+    category: 'Advanced',
+    requiresRestart: true,
+    default: undefined as string[] | undefined,
+    description: 'A blacklist of MCP servers to exclude.',
+    showInDialog: false,
+  },
+  telemetry: {
+    type: 'object',
+    label: 'Telemetry',
+    category: 'Advanced',
+    requiresRestart: true,
+    default: undefined as TelemetrySettings | undefined,
+    description: 'Telemetry configuration.',
+    showInDialog: false,
+  },
+  bugCommand: {
+    type: 'object',
+    label: 'Bug Command',
+    category: 'Advanced',
+    requiresRestart: false,
+    default: undefined as BugCommandSettings | undefined,
+    description: 'Configuration for the bug report command.',
+    showInDialog: false,
+  },
+  summarizeToolOutput: {
+    type: 'object',
+    label: 'Summarize Tool Output',
+    category: 'Advanced',
+    requiresRestart: false,
+    default: undefined as Record<string, { tokenBudget?: number }> | undefined,
+    description: 'Settings for summarizing tool output.',
+    showInDialog: false,
+  },
+  ideModeFeature: {
+    type: 'boolean',
+    label: 'IDE Mode Feature Flag',
+    category: 'Advanced',
+    requiresRestart: true,
+    default: undefined as boolean | undefined,
+    description: 'Internal feature flag for IDE mode.',
+    showInDialog: false,
+  },
+  dnsResolutionOrder: {
+    type: 'string',
+    label: 'DNS Resolution Order',
+    category: 'Advanced',
+    requiresRestart: true,
+    default: undefined as DnsResolutionOrder | undefined,
+    description: 'The DNS resolution order.',
+    showInDialog: false,
+  },
+  excludedProjectEnvVars: {
+    type: 'array',
+    label: 'Excluded Project Environment Variables',
+    category: 'Advanced',
+    requiresRestart: false,
+    default: ['DEBUG', 'DEBUG_MODE'] as string[],
+    description: 'Environment variables to exclude from project context.',
+    showInDialog: false,
+  },
+  disableUpdateNag: {
+    type: 'boolean',
+    label: 'Disable Update Nag',
+    category: 'Updates',
+    requiresRestart: false,
+    default: false,
+    description: 'Disable update notification prompts.',
+    showInDialog: false,
+  },
+  includeDirectories: {
+    type: 'array',
+    label: 'Include Directories',
+    category: 'General',
+    requiresRestart: false,
+    default: [] as string[],
+    description: 'Additional directories to include in the workspace context.',
+    showInDialog: false,
+  },
+  loadMemoryFromIncludeDirectories: {
+    type: 'boolean',
+    label: 'Load Memory From Include Directories',
+    category: 'General',
+    requiresRestart: false,
+    default: false,
+    description: 'Whether to load memory files from include directories.',
+    showInDialog: true,
+  },
+  model: {
+    type: 'string',
+    label: 'Model',
+    category: 'General',
+    requiresRestart: false,
+    default: undefined as string | undefined,
+    description: 'The Gemini model to use for conversations.',
+    showInDialog: false,
+  },
+  hasSeenIdeIntegrationNudge: {
+    type: 'boolean',
+    label: 'Has Seen IDE Integration Nudge',
+    category: 'General',
+    requiresRestart: false,
+    default: false,
+    description: 'Whether the user has seen the IDE integration nudge.',
+    showInDialog: false,
+  },
+  folderTrustFeature: {
+    type: 'boolean',
+    label: 'Folder Trust Feature',
+    category: 'General',
+    requiresRestart: false,
+    default: false,
+    description: 'Enable folder trust feature for enhanced security.',
+    showInDialog: true,
+  },
+  folderTrust: {
+    type: 'boolean',
+    label: 'Folder Trust',
+    category: 'General',
+    requiresRestart: false,
+    default: false,
+    description: 'Setting to track whether Folder trust is enabled.',
+    showInDialog: true,
+  },
+  chatCompression: {
+    type: 'object',
+    label: 'Chat Compression',
+    category: 'General',
+    requiresRestart: false,
+    default: undefined as ChatCompressionSettings | undefined,
+    description: 'Chat compression settings.',
+    showInDialog: false,
+  },
+  showLineNumbers: {
+    type: 'boolean',
+    label: 'Show Line Numbers',
+    category: 'General',
+    requiresRestart: false,
+    default: false,
+    description: 'Show line numbers in the chat.',
+    showInDialog: true,
+  },
+} as const;
+
+type InferSettings<T extends SettingsSchema> = {
+  -readonly [K in keyof T]?: T[K] extends { properties: SettingsSchema }
+    ? InferSettings<T[K]['properties']>
+    : T[K]['default'] extends boolean
+      ? boolean
+      : T[K]['default'];
+};
+
+export type Settings = InferSettings<typeof SETTINGS_SCHEMA>;
diff --git a/packages/cli/src/services/BuiltinCommandLoader.ts b/packages/cli/src/services/BuiltinCommandLoader.ts
index c09f7c61..639bb4d8 100644
--- a/packages/cli/src/services/BuiltinCommandLoader.ts
+++ b/packages/cli/src/services/BuiltinCommandLoader.ts
@@ -30,6 +30,7 @@ import { restoreCommand } from '../ui/commands/restoreCommand.js';
 import { statsCommand } from '../ui/commands/statsCommand.js';
 import { themeCommand } from '../ui/commands/themeCommand.js';
 import { toolsCommand } from '../ui/commands/toolsCommand.js';
+import { settingsCommand } from '../ui/commands/settingsCommand.js';
 import { vimCommand } from '../ui/commands/vimCommand.js';
 import { setupGithubCommand } from '../ui/commands/setupGithubCommand.js';
 
@@ -72,6 +73,7 @@ export class BuiltinCommandLoader implements ICommandLoader {
       statsCommand,
       themeCommand,
       toolsCommand,
+      settingsCommand,
       vimCommand,
       setupGithubCommand,
     ];
diff --git a/packages/cli/src/ui/App.tsx b/packages/cli/src/ui/App.tsx
index a52236f8..aff3fac3 100644
--- a/packages/cli/src/ui/App.tsx
+++ b/packages/cli/src/ui/App.tsx
@@ -93,6 +93,8 @@ import ansiEscapes from 'ansi-escapes';
 import { OverflowProvider } from './contexts/OverflowContext.js';
 import { ShowMoreLines } from './components/ShowMoreLines.js';
 import { PrivacyNotice } from './privacy/PrivacyNotice.js';
+import { useSettingsCommand } from './hooks/useSettingsCommand.js';
+import { SettingsDialog } from './components/SettingsDialog.js';
 import { setUpdateHandler } from '../utils/handleAutoUpdate.js';
 import { appEvents, AppEvent } from '../utils/events.js';
 import { isNarrowWidth } from './utils/isNarrowWidth.js';
@@ -247,6 +249,9 @@ const App = ({ config, settings, startupWarnings = [], version }: AppProps) => {
     handleThemeHighlight,
   } = useThemeCommand(settings, setThemeError, addItem);
 
+  const { isSettingsDialogOpen, openSettingsDialog, closeSettingsDialog } =
+    useSettingsCommand();
+
   const { isFolderTrustDialogOpen, handleFolderTrustSelect } =
     useFolderTrust(settings);
 
@@ -510,6 +515,7 @@ const App = ({ config, settings, startupWarnings = [], version }: AppProps) => {
     toggleCorgiMode,
     setQuittingMessages,
     openPrivacyNotice,
+    openSettingsDialog,
     toggleVimEnabled,
     setIsProcessing,
     setGeminiMdFileCount,
@@ -975,6 +981,14 @@ const App = ({ config, settings, startupWarnings = [], version }: AppProps) => {
                 terminalWidth={mainAreaWidth}
               />
             </Box>
+          ) : isSettingsDialogOpen ? (
+            <Box flexDirection="column">
+              <SettingsDialog
+                settings={settings}
+                onSelect={() => closeSettingsDialog()}
+                onRestartRequest={() => process.exit(0)}
+              />
+            </Box>
           ) : isAuthenticating ? (
             <>
               <AuthInProgress
@@ -1164,7 +1178,7 @@ const App = ({ config, settings, startupWarnings = [], version }: AppProps) => {
             errorCount={errorCount}
             showErrorDetails={showErrorDetails}
             showMemoryUsage={
-              config.getDebugMode() || config.getShowMemoryUsage()
+              config.getDebugMode() || settings.merged.showMemoryUsage || false
             }
             promptTokenCount={sessionStats.lastPromptTokenCount}
             nightly={nightly}
diff --git a/packages/cli/src/ui/commands/settingsCommand.test.ts b/packages/cli/src/ui/commands/settingsCommand.test.ts
new file mode 100644
index 00000000..96d0d511
--- /dev/null
+++ b/packages/cli/src/ui/commands/settingsCommand.test.ts
@@ -0,0 +1,36 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { describe, it, expect, beforeEach } from 'vitest';
+import { settingsCommand } from './settingsCommand.js';
+import { type CommandContext } from './types.js';
+import { createMockCommandContext } from '../../test-utils/mockCommandContext.js';
+
+describe('settingsCommand', () => {
+  let mockContext: CommandContext;
+
+  beforeEach(() => {
+    mockContext = createMockCommandContext();
+  });
+
+  it('should return a dialog action to open the settings dialog', () => {
+    if (!settingsCommand.action) {
+      throw new Error('The settings command must have an action.');
+    }
+    const result = settingsCommand.action(mockContext, '');
+    expect(result).toEqual({
+      type: 'dialog',
+      dialog: 'settings',
+    });
+  });
+
+  it('should have the correct name and description', () => {
+    expect(settingsCommand.name).toBe('settings');
+    expect(settingsCommand.description).toBe(
+      'View and edit Gemini CLI settings',
+    );
+  });
+});
diff --git a/packages/cli/src/ui/commands/settingsCommand.ts b/packages/cli/src/ui/commands/settingsCommand.ts
new file mode 100644
index 00000000..26807852
--- /dev/null
+++ b/packages/cli/src/ui/commands/settingsCommand.ts
@@ -0,0 +1,17 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { CommandKind, OpenDialogActionReturn, SlashCommand } from './types.js';
+
+export const settingsCommand: SlashCommand = {
+  name: 'settings',
+  description: 'View and edit Gemini CLI settings',
+  kind: CommandKind.BUILT_IN,
+  action: (_context, _args): OpenDialogActionReturn => ({
+    type: 'dialog',
+    dialog: 'settings',
+  }),
+};
diff --git a/packages/cli/src/ui/commands/types.ts b/packages/cli/src/ui/commands/types.ts
index 529f4eb8..d4f0b454 100644
--- a/packages/cli/src/ui/commands/types.ts
+++ b/packages/cli/src/ui/commands/types.ts
@@ -102,7 +102,8 @@ export interface MessageActionReturn {
  */
 export interface OpenDialogActionReturn {
   type: 'dialog';
-  dialog: 'auth' | 'theme' | 'editor' | 'privacy';
+
+  dialog: 'help' | 'auth' | 'theme' | 'editor' | 'privacy' | 'settings';
 }
 
 /**
diff --git a/packages/cli/src/ui/components/SettingsDialog.test.tsx b/packages/cli/src/ui/components/SettingsDialog.test.tsx
new file mode 100644
index 00000000..ed67dcf9
--- /dev/null
+++ b/packages/cli/src/ui/components/SettingsDialog.test.tsx
@@ -0,0 +1,831 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ *
+ *
+ * This test suite covers:
+ * - Initial rendering and display state
+ * - Keyboard navigation (arrows, vim keys, Tab)
+ * - Settings toggling (Enter, Space)
+ * - Focus section switching between settings and scope selector
+ * - Scope selection and settings persistence across scopes
+ * - Restart-required vs immediate settings behavior
+ * - VimModeContext integration
+ * - Complex user interaction workflows
+ * - Error handling and edge cases
+ * - Display values for inherited and overridden settings
+ *
+ */
+
+import { render } from 'ink-testing-library';
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { SettingsDialog } from './SettingsDialog.js';
+import { LoadedSettings, SettingScope } from '../../config/settings.js';
+import { VimModeProvider } from '../contexts/VimModeContext.js';
+
+// Mock the VimModeContext
+const mockToggleVimEnabled = vi.fn();
+const mockSetVimMode = vi.fn();
+
+vi.mock('../contexts/VimModeContext.js', async () => {
+  const actual = await vi.importActual('../contexts/VimModeContext.js');
+  return {
+    ...actual,
+    useVimMode: () => ({
+      vimEnabled: false,
+      vimMode: 'INSERT' as const,
+      toggleVimEnabled: mockToggleVimEnabled,
+      setVimMode: mockSetVimMode,
+    }),
+  };
+});
+
+vi.mock('../../utils/settingsUtils.js', async () => {
+  const actual = await vi.importActual('../../utils/settingsUtils.js');
+  return {
+    ...actual,
+    saveModifiedSettings: vi.fn(),
+  };
+});
+
+// Mock console.log to avoid noise in tests
+const originalConsoleLog = console.log;
+const originalConsoleError = console.error;
+
+describe('SettingsDialog', () => {
+  const wait = (ms = 50) => new Promise((resolve) => setTimeout(resolve, ms));
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    console.log = vi.fn();
+    console.error = vi.fn();
+    mockToggleVimEnabled.mockResolvedValue(true);
+  });
+
+  afterEach(() => {
+    console.log = originalConsoleLog;
+    console.error = originalConsoleError;
+  });
+
+  const createMockSettings = (
+    userSettings = {},
+    systemSettings = {},
+    workspaceSettings = {},
+  ) =>
+    new LoadedSettings(
+      {
+        settings: { customThemes: {}, mcpServers: {}, ...systemSettings },
+        path: '/system/settings.json',
+      },
+      {
+        settings: {
+          customThemes: {},
+          mcpServers: {},
+          ...userSettings,
+        },
+        path: '/user/settings.json',
+      },
+      {
+        settings: { customThemes: {}, mcpServers: {}, ...workspaceSettings },
+        path: '/workspace/settings.json',
+      },
+      [],
+    );
+
+  describe('Initial Rendering', () => {
+    it('should render the settings dialog with default state', () => {
+      const settings = createMockSettings();
+      const onSelect = vi.fn();
+
+      const { lastFrame } = render(
+        <SettingsDialog settings={settings} onSelect={onSelect} />,
+      );
+
+      const output = lastFrame();
+      expect(output).toContain('Settings');
+      expect(output).toContain('Apply To');
+      expect(output).toContain('Use Enter to select, Tab to change focus');
+    });
+
+    it('should show settings list with default values', () => {
+      const settings = createMockSettings();
+      const onSelect = vi.fn();
+
+      const { lastFrame } = render(
+        <SettingsDialog settings={settings} onSelect={onSelect} />,
+      );
+
+      const output = lastFrame();
+      // Should show some default settings
+      expect(output).toContain('●'); // Active indicator
+    });
+
+    it('should highlight first setting by default', () => {
+      const settings = createMockSettings();
+      const onSelect = vi.fn();
+
+      const { lastFrame } = render(
+        <SettingsDialog settings={settings} onSelect={onSelect} />,
+      );
+
+      const output = lastFrame();
+      // First item should be highlighted with green color and active indicator
+      expect(output).toContain('●');
+    });
+  });
+
+  describe('Settings Navigation', () => {
+    it('should navigate down with arrow key', async () => {
+      const settings = createMockSettings();
+      const onSelect = vi.fn();
+
+      const { stdin, unmount } = render(
+        <SettingsDialog settings={settings} onSelect={onSelect} />,
+      );
+
+      // Press down arrow
+      stdin.write('\u001B[B'); // Down arrow
+      await wait();
+
+      // The active index should have changed (tested indirectly through behavior)
+      unmount();
+    });
+
+    it('should navigate up with arrow key', async () => {
+      const settings = createMockSettings();
+      const onSelect = vi.fn();
+
+      const { stdin, unmount } = render(
+        <SettingsDialog settings={settings} onSelect={onSelect} />,
+      );
+
+      // First go down, then up
+      stdin.write('\u001B[B'); // Down arrow
+      await wait();
+      stdin.write('\u001B[A'); // Up arrow
+      await wait();
+
+      unmount();
+    });
+
+    it('should navigate with vim keys (j/k)', async () => {
+      const settings = createMockSettings();
+      const onSelect = vi.fn();
+
+      const { stdin, unmount } = render(
+        <SettingsDialog settings={settings} onSelect={onSelect} />,
+      );
+
+      // Navigate with vim keys
+      stdin.write('j'); // Down
+      await wait();
+      stdin.write('k'); // Up
+      await wait();
+
+      unmount();
+    });
+
+    it('should not navigate beyond bounds', async () => {
+      const settings = createMockSettings();
+      const onSelect = vi.fn();
+
+      const { stdin, unmount } = render(
+        <SettingsDialog settings={settings} onSelect={onSelect} />,
+      );
+
+      // Try to go up from first item
+      stdin.write('\u001B[A'); // Up arrow
+      await wait();
+
+      // Should still be on first item
+      unmount();
+    });
+  });
+
+  describe('Settings Toggling', () => {
+    it('should toggle setting with Enter key', async () => {
+      const settings = createMockSettings();
+      const onSelect = vi.fn();
+
+      const { stdin, unmount } = render(
+        <SettingsDialog settings={settings} onSelect={onSelect} />,
+      );
+
+      // Press Enter to toggle current setting
+      stdin.write('\u000D'); // Enter key
+      await wait();
+
+      unmount();
+    });
+
+    it('should toggle setting with Space key', async () => {
+      const settings = createMockSettings();
+      const onSelect = vi.fn();
+
+      const { stdin, unmount } = render(
+        <SettingsDialog settings={settings} onSelect={onSelect} />,
+      );
+
+      // Press Space to toggle current setting
+      stdin.write(' '); // Space key
+      await wait();
+
+      unmount();
+    });
+
+    it('should handle vim mode setting specially', async () => {
+      const settings = createMockSettings();
+      const onSelect = vi.fn();
+
+      const { stdin, unmount } = render(
+        <SettingsDialog settings={settings} onSelect={onSelect} />,
+      );
+
+      // Navigate to vim mode setting and toggle it
+      // This would require knowing the exact position, so we'll just test that the mock is called
+      stdin.write('\u000D'); // Enter key
+      await wait();
+
+      // The mock should potentially be called if vim mode was toggled
+      unmount();
+    });
+  });
+
+  describe('Scope Selection', () => {
+    it('should switch between scopes', async () => {
+      const settings = createMockSettings();
+      const onSelect = vi.fn();
+
+      const { stdin, unmount } = render(
+        <SettingsDialog settings={settings} onSelect={onSelect} />,
+      );
+
+      // Switch to scope focus
+      stdin.write('\t'); // Tab key
+      await wait();
+
+      // Select different scope (numbers 1-3 typically available)
+      stdin.write('2'); // Select second scope option
+      await wait();
+
+      unmount();
+    });
+
+    it('should reset to settings focus when scope is selected', async () => {
+      const settings = createMockSettings();
+      const onSelect = vi.fn();
+
+      const { lastFrame, stdin, unmount } = render(
+        <SettingsDialog settings={settings} onSelect={onSelect} />,
+      );
+
+      // Switch to scope focus
+      stdin.write('\t'); // Tab key
+      await wait();
+      expect(lastFrame()).toContain('> Apply To');
+
+      // Select a scope
+      stdin.write('1'); // Select first scope option
+      await wait();
+
+      // Should be back to settings focus
+      expect(lastFrame()).toContain('  Apply To');
+
+      unmount();
+    });
+  });
+
+  describe('Restart Prompt', () => {
+    it('should show restart prompt for restart-required settings', async () => {
+      const settings = createMockSettings();
+      const onRestartRequest = vi.fn();
+
+      const { unmount } = render(
+        <SettingsDialog
+          settings={settings}
+          onSelect={() => {}}
+          onRestartRequest={onRestartRequest}
+        />,
+      );
+
+      // This test would need to trigger a restart-required setting change
+      // The exact steps depend on which settings require restart
+      await wait();
+
+      unmount();
+    });
+
+    it('should handle restart request when r is pressed', async () => {
+      const settings = createMockSettings();
+      const onRestartRequest = vi.fn();
+
+      const { stdin, unmount } = render(
+        <SettingsDialog
+          settings={settings}
+          onSelect={() => {}}
+          onRestartRequest={onRestartRequest}
+        />,
+      );
+
+      // Press 'r' key (this would only work if restart prompt is showing)
+      stdin.write('r');
+      await wait();
+
+      // If restart prompt was showing, onRestartRequest should be called
+      unmount();
+    });
+  });
+
+  describe('Escape Key Behavior', () => {
+    it('should call onSelect with undefined when Escape is pressed', async () => {
+      const settings = createMockSettings();
+      const onSelect = vi.fn();
+
+      const { stdin, unmount } = render(
+        <SettingsDialog settings={settings} onSelect={onSelect} />,
+      );
+
+      // Press Escape key
+      stdin.write('\u001B'); // ESC key
+      await wait();
+
+      expect(onSelect).toHaveBeenCalledWith(undefined, SettingScope.User);
+
+      unmount();
+    });
+  });
+
+  describe('Settings Persistence', () => {
+    it('should persist settings across scope changes', async () => {
+      const settings = createMockSettings({ vimMode: true });
+      const onSelect = vi.fn();
+
+      const { stdin, unmount } = render(
+        <SettingsDialog settings={settings} onSelect={onSelect} />,
+      );
+
+      // Switch to scope selector
+      stdin.write('\t'); // Tab
+      await wait();
+
+      // Change scope
+      stdin.write('2'); // Select workspace scope
+      await wait();
+
+      // Settings should be reloaded for new scope
+      unmount();
+    });
+
+    it('should show different values for different scopes', () => {
+      const settings = createMockSettings(
+        { vimMode: true }, // User settings
+        { vimMode: false }, // System settings
+        { autoUpdate: false }, // Workspace settings
+      );
+      const onSelect = vi.fn();
+
+      const { lastFrame } = render(
+        <SettingsDialog settings={settings} onSelect={onSelect} />,
+      );
+
+      // Should show user scope values initially
+      const output = lastFrame();
+      expect(output).toContain('Settings');
+    });
+  });
+
+  describe('Error Handling', () => {
+    it('should handle vim mode toggle errors gracefully', async () => {
+      mockToggleVimEnabled.mockRejectedValue(new Error('Toggle failed'));
+
+      const settings = createMockSettings();
+      const onSelect = vi.fn();
+
+      const { stdin, unmount } = render(
+        <SettingsDialog settings={settings} onSelect={onSelect} />,
+      );
+
+      // Try to toggle a setting (this might trigger vim mode toggle)
+      stdin.write('\u000D'); // Enter
+      await wait();
+
+      // Should not crash
+      unmount();
+    });
+  });
+
+  describe('Complex State Management', () => {
+    it('should track modified settings correctly', async () => {
+      const settings = createMockSettings();
+      const onSelect = vi.fn();
+
+      const { stdin, unmount } = render(
+        <SettingsDialog settings={settings} onSelect={onSelect} />,
+      );
+
+      // Toggle a setting
+      stdin.write('\u000D'); // Enter
+      await wait();
+
+      // Toggle another setting
+      stdin.write('\u001B[B'); // Down
+      await wait();
+      stdin.write('\u000D'); // Enter
+      await wait();
+
+      // Should track multiple modified settings
+      unmount();
+    });
+
+    it('should handle scrolling when there are many settings', async () => {
+      const settings = createMockSettings();
+      const onSelect = vi.fn();
+
+      const { stdin, unmount } = render(
+        <SettingsDialog settings={settings} onSelect={onSelect} />,
+      );
+
+      // Navigate down many times to test scrolling
+      for (let i = 0; i < 10; i++) {
+        stdin.write('\u001B[B'); // Down arrow
+        await wait(10);
+      }
+
+      unmount();
+    });
+  });
+
+  describe('VimMode Integration', () => {
+    it('should sync with VimModeContext when vim mode is toggled', async () => {
+      const settings = createMockSettings();
+      const onSelect = vi.fn();
+
+      const { stdin, unmount } = render(
+        <VimModeProvider settings={settings}>
+          <SettingsDialog settings={settings} onSelect={onSelect} />
+        </VimModeProvider>,
+      );
+
+      // Navigate to and toggle vim mode setting
+      // This would require knowing the exact position of vim mode setting
+      stdin.write('\u000D'); // Enter
+      await wait();
+
+      unmount();
+    });
+  });
+
+  describe('Specific Settings Behavior', () => {
+    it('should show correct display values for settings with different states', () => {
+      const settings = createMockSettings(
+        { vimMode: true, hideTips: false }, // User settings
+        { hideWindowTitle: true }, // System settings
+        { ideMode: false }, // Workspace settings
+      );
+      const onSelect = vi.fn();
+
+      const { lastFrame } = render(
+        <SettingsDialog settings={settings} onSelect={onSelect} />,
+      );
+
+      const output = lastFrame();
+      // Should contain settings labels
+      expect(output).toContain('Settings');
+    });
+
+    it('should handle immediate settings save for non-restart-required settings', async () => {
+      const settings = createMockSettings();
+      const onSelect = vi.fn();
+
+      const { stdin, unmount } = render(
+        <SettingsDialog settings={settings} onSelect={onSelect} />,
+      );
+
+      // Toggle a non-restart-required setting (like hideTips)
+      stdin.write('\u000D'); // Enter - toggle current setting
+      await wait();
+
+      // Should save immediately without showing restart prompt
+      unmount();
+    });
+
+    it('should show restart prompt for restart-required settings', async () => {
+      const settings = createMockSettings();
+      const onSelect = vi.fn();
+
+      const { lastFrame, unmount } = render(
+        <SettingsDialog settings={settings} onSelect={onSelect} />,
+      );
+
+      // This test would need to navigate to a specific restart-required setting
+      // Since we can't easily target specific settings, we test the general behavior
+      await wait();
+
+      // Should not show restart prompt initially
+      expect(lastFrame()).not.toContain(
+        'To see changes, Gemini CLI must be restarted',
+      );
+
+      unmount();
+    });
+
+    it('should clear restart prompt when switching scopes', async () => {
+      const settings = createMockSettings();
+      const onSelect = vi.fn();
+
+      const { unmount } = render(
+        <SettingsDialog settings={settings} onSelect={onSelect} />,
+      );
+
+      // Restart prompt should be cleared when switching scopes
+      unmount();
+    });
+  });
+
+  describe('Settings Display Values', () => {
+    it('should show correct values for inherited settings', () => {
+      const settings = createMockSettings(
+        {}, // No user settings
+        { vimMode: true, hideWindowTitle: false }, // System settings
+        {}, // No workspace settings
+      );
+      const onSelect = vi.fn();
+
+      const { lastFrame } = render(
+        <SettingsDialog settings={settings} onSelect={onSelect} />,
+      );
+
+      const output = lastFrame();
+      // Settings should show inherited values
+      expect(output).toContain('Settings');
+    });
+
+    it('should show override indicator for overridden settings', () => {
+      const settings = createMockSettings(
+        { vimMode: false }, // User overrides
+        { vimMode: true }, // System default
+        {}, // No workspace settings
+      );
+      const onSelect = vi.fn();
+
+      const { lastFrame } = render(
+        <SettingsDialog settings={settings} onSelect={onSelect} />,
+      );
+
+      const output = lastFrame();
+      // Should show settings with override indicators
+      expect(output).toContain('Settings');
+    });
+  });
+
+  describe('Keyboard Shortcuts Edge Cases', () => {
+    it('should handle rapid key presses gracefully', async () => {
+      const settings = createMockSettings();
+      const onSelect = vi.fn();
+
+      const { stdin, unmount } = render(
+        <SettingsDialog settings={settings} onSelect={onSelect} />,
+      );
+
+      // Rapid navigation
+      for (let i = 0; i < 5; i++) {
+        stdin.write('\u001B[B'); // Down arrow
+        stdin.write('\u001B[A'); // Up arrow
+      }
+      await wait(100);
+
+      // Should not crash
+      unmount();
+    });
+
+    it('should handle Ctrl+C to reset current setting to default', async () => {
+      const settings = createMockSettings({ vimMode: true }); // Start with vimMode enabled
+      const onSelect = vi.fn();
+
+      const { stdin, unmount } = render(
+        <SettingsDialog settings={settings} onSelect={onSelect} />,
+      );
+
+      // Press Ctrl+C to reset current setting to default
+      stdin.write('\u0003'); // Ctrl+C
+      await wait();
+
+      // Should reset the current setting to its default value
+      unmount();
+    });
+
+    it('should handle Ctrl+L to reset current setting to default', async () => {
+      const settings = createMockSettings({ vimMode: true }); // Start with vimMode enabled
+      const onSelect = vi.fn();
+
+      const { stdin, unmount } = render(
+        <SettingsDialog settings={settings} onSelect={onSelect} />,
+      );
+
+      // Press Ctrl+L to reset current setting to default
+      stdin.write('\u000C'); // Ctrl+L
+      await wait();
+
+      // Should reset the current setting to its default value
+      unmount();
+    });
+
+    it('should handle navigation when only one setting exists', async () => {
+      const settings = createMockSettings();
+      const onSelect = vi.fn();
+
+      const { stdin, unmount } = render(
+        <SettingsDialog settings={settings} onSelect={onSelect} />,
+      );
+
+      // Try to navigate when potentially at bounds
+      stdin.write('\u001B[B'); // Down
+      await wait();
+      stdin.write('\u001B[A'); // Up
+      await wait();
+
+      unmount();
+    });
+
+    it('should properly handle Tab navigation between sections', async () => {
+      const settings = createMockSettings();
+      const onSelect = vi.fn();
+
+      const { lastFrame, stdin, unmount } = render(
+        <SettingsDialog settings={settings} onSelect={onSelect} />,
+      );
+
+      // Start in settings section
+      expect(lastFrame()).toContain('  Apply To');
+
+      // Tab to scope section
+      stdin.write('\t');
+      await wait();
+      expect(lastFrame()).toContain('> Apply To');
+
+      // Tab back to settings section
+      stdin.write('\t');
+      await wait();
+      expect(lastFrame()).toContain('  Apply To');
+
+      unmount();
+    });
+  });
+
+  describe('Error Recovery', () => {
+    it('should handle malformed settings gracefully', () => {
+      // Create settings with potentially problematic values
+      const settings = createMockSettings(
+        { vimMode: null as unknown as boolean }, // Invalid value
+        {},
+        {},
+      );
+      const onSelect = vi.fn();
+
+      const { lastFrame } = render(
+        <SettingsDialog settings={settings} onSelect={onSelect} />,
+      );
+
+      // Should still render without crashing
+      expect(lastFrame()).toContain('Settings');
+    });
+
+    it('should handle missing setting definitions gracefully', () => {
+      const settings = createMockSettings();
+      const onSelect = vi.fn();
+
+      // Should not crash even if some settings are missing definitions
+      const { lastFrame } = render(
+        <SettingsDialog settings={settings} onSelect={onSelect} />,
+      );
+
+      expect(lastFrame()).toContain('Settings');
+    });
+  });
+
+  describe('Complex User Interactions', () => {
+    it('should handle complete user workflow: navigate, toggle, change scope, exit', async () => {
+      const settings = createMockSettings();
+      const onSelect = vi.fn();
+
+      const { stdin, unmount } = render(
+        <SettingsDialog settings={settings} onSelect={onSelect} />,
+      );
+
+      // Navigate down a few settings
+      stdin.write('\u001B[B'); // Down
+      await wait();
+      stdin.write('\u001B[B'); // Down
+      await wait();
+
+      // Toggle a setting
+      stdin.write('\u000D'); // Enter
+      await wait();
+
+      // Switch to scope selector
+      stdin.write('\t'); // Tab
+      await wait();
+
+      // Change scope
+      stdin.write('2'); // Select workspace
+      await wait();
+
+      // Go back to settings
+      stdin.write('\t'); // Tab
+      await wait();
+
+      // Navigate and toggle another setting
+      stdin.write('\u001B[B'); // Down
+      await wait();
+      stdin.write(' '); // Space to toggle
+      await wait();
+
+      // Exit
+      stdin.write('\u001B'); // Escape
+      await wait();
+
+      expect(onSelect).toHaveBeenCalledWith(undefined, expect.any(String));
+
+      unmount();
+    });
+
+    it('should allow changing multiple settings without losing pending changes', async () => {
+      const settings = createMockSettings();
+      const onSelect = vi.fn();
+
+      const { stdin, unmount } = render(
+        <SettingsDialog settings={settings} onSelect={onSelect} />,
+      );
+
+      // Toggle first setting (should require restart)
+      stdin.write('\u000D'); // Enter
+      await wait();
+
+      // Navigate to next setting and toggle it (should not require restart - e.g., vimMode)
+      stdin.write('\u001B[B'); // Down
+      await wait();
+      stdin.write('\u000D'); // Enter
+      await wait();
+
+      // Navigate to another setting and toggle it (should also require restart)
+      stdin.write('\u001B[B'); // Down
+      await wait();
+      stdin.write('\u000D'); // Enter
+      await wait();
+
+      // The test verifies that all changes are preserved and the dialog still works
+      // This tests the fix for the bug where changing one setting would reset all pending changes
+      unmount();
+    });
+
+    it('should maintain state consistency during complex interactions', async () => {
+      const settings = createMockSettings({ vimMode: true });
+      const onSelect = vi.fn();
+
+      const { stdin, unmount } = render(
+        <SettingsDialog settings={settings} onSelect={onSelect} />,
+      );
+
+      // Multiple scope changes
+      stdin.write('\t'); // Tab to scope
+      await wait();
+      stdin.write('2'); // Workspace
+      await wait();
+      stdin.write('\t'); // Tab to settings
+      await wait();
+      stdin.write('\t'); // Tab to scope
+      await wait();
+      stdin.write('1'); // User
+      await wait();
+
+      // Should maintain consistent state
+      unmount();
+    });
+
+    it('should handle restart workflow correctly', async () => {
+      const settings = createMockSettings();
+      const onRestartRequest = vi.fn();
+
+      const { stdin, unmount } = render(
+        <SettingsDialog
+          settings={settings}
+          onSelect={() => {}}
+          onRestartRequest={onRestartRequest}
+        />,
+      );
+
+      // This would test the restart workflow if we could trigger it
+      stdin.write('r'); // Try restart key
+      await wait();
+
+      // Without restart prompt showing, this should have no effect
+      expect(onRestartRequest).not.toHaveBeenCalled();
+
+      unmount();
+    });
+  });
+});
diff --git a/packages/cli/src/ui/components/SettingsDialog.tsx b/packages/cli/src/ui/components/SettingsDialog.tsx
new file mode 100644
index 00000000..80e2339f
--- /dev/null
+++ b/packages/cli/src/ui/components/SettingsDialog.tsx
@@ -0,0 +1,465 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import React, { useState, useEffect } from 'react';
+import { Box, Text, useInput } from 'ink';
+import { Colors } from '../colors.js';
+import {
+  LoadedSettings,
+  SettingScope,
+  Settings,
+} from '../../config/settings.js';
+import {
+  getScopeItems,
+  getScopeMessageForSetting,
+} from '../../utils/dialogScopeUtils.js';
+import { RadioButtonSelect } from './shared/RadioButtonSelect.js';
+import {
+  getDialogSettingKeys,
+  getSettingValue,
+  setPendingSettingValue,
+  getDisplayValue,
+  hasRestartRequiredSettings,
+  saveModifiedSettings,
+  getSettingDefinition,
+  isDefaultValue,
+  requiresRestart,
+  getRestartRequiredFromModified,
+  getDefaultValue,
+} from '../../utils/settingsUtils.js';
+import { useVimMode } from '../contexts/VimModeContext.js';
+
+interface SettingsDialogProps {
+  settings: LoadedSettings;
+  onSelect: (settingName: string | undefined, scope: SettingScope) => void;
+  onRestartRequest?: () => void;
+}
+
+const maxItemsToShow = 8;
+
+export function SettingsDialog({
+  settings,
+  onSelect,
+  onRestartRequest,
+}: SettingsDialogProps): React.JSX.Element {
+  // Get vim mode context to sync vim mode changes
+  const { vimEnabled, toggleVimEnabled } = useVimMode();
+
+  // Focus state: 'settings' or 'scope'
+  const [focusSection, setFocusSection] = useState<'settings' | 'scope'>(
+    'settings',
+  );
+  // Scope selector state (User by default)
+  const [selectedScope, setSelectedScope] = useState<SettingScope>(
+    SettingScope.User,
+  );
+  // Active indices
+  const [activeSettingIndex, setActiveSettingIndex] = useState(0);
+  // Scroll offset for settings
+  const [scrollOffset, setScrollOffset] = useState(0);
+  const [showRestartPrompt, setShowRestartPrompt] = useState(false);
+
+  // Local pending settings state for the selected scope
+  const [pendingSettings, setPendingSettings] = useState<Settings>(() =>
+    // Deep clone to avoid mutation
+    structuredClone(settings.forScope(selectedScope).settings),
+  );
+
+  // Track which settings have been modified by the user
+  const [modifiedSettings, setModifiedSettings] = useState<Set<string>>(
+    new Set(),
+  );
+
+  // Track the intended values for modified settings
+  const [modifiedValues, setModifiedValues] = useState<Map<string, boolean>>(
+    new Map(),
+  );
+
+  // Track restart-required settings across scope changes
+  const [restartRequiredSettings, setRestartRequiredSettings] = useState<
+    Set<string>
+  >(new Set());
+
+  useEffect(() => {
+    setPendingSettings(
+      structuredClone(settings.forScope(selectedScope).settings),
+    );
+    // Don't reset modifiedSettings when scope changes - preserve user's pending changes
+    if (restartRequiredSettings.size === 0) {
+      setShowRestartPrompt(false);
+    }
+  }, [selectedScope, settings, restartRequiredSettings]);
+
+  // Preserve pending changes when scope changes
+  useEffect(() => {
+    if (modifiedSettings.size > 0) {
+      setPendingSettings((prevPending) => {
+        let updatedPending = { ...prevPending };
+
+        // Reapply all modified settings to the new pending settings using stored values
+        modifiedSettings.forEach((key) => {
+          const storedValue = modifiedValues.get(key);
+          if (storedValue !== undefined) {
+            updatedPending = setPendingSettingValue(
+              key,
+              storedValue,
+              updatedPending,
+            );
+          }
+        });
+
+        return updatedPending;
+      });
+    }
+  }, [selectedScope, modifiedSettings, modifiedValues, settings]);
+
+  const generateSettingsItems = () => {
+    const settingKeys = getDialogSettingKeys();
+
+    return settingKeys.map((key: string) => {
+      const currentValue = getSettingValue(key, pendingSettings, {});
+      const definition = getSettingDefinition(key);
+
+      return {
+        label: definition?.label || key,
+        value: key,
+        checked: currentValue,
+        toggle: () => {
+          const newValue = !currentValue;
+
+          setPendingSettings((prev) =>
+            setPendingSettingValue(key, newValue, prev),
+          );
+
+          if (!requiresRestart(key)) {
+            const immediateSettings = new Set([key]);
+            const immediateSettingsObject = setPendingSettingValue(
+              key,
+              newValue,
+              {},
+            );
+
+            console.log(
+              `[DEBUG SettingsDialog] Saving ${key} immediately with value:`,
+              newValue,
+            );
+            saveModifiedSettings(
+              immediateSettings,
+              immediateSettingsObject,
+              settings,
+              selectedScope,
+            );
+
+            // Special handling for vim mode to sync with VimModeContext
+            if (key === 'vimMode' && newValue !== vimEnabled) {
+              // Call toggleVimEnabled to sync the VimModeContext local state
+              toggleVimEnabled().catch((error) => {
+                console.error('Failed to toggle vim mode:', error);
+              });
+            }
+
+            // Capture the current modified settings before updating state
+            const currentModifiedSettings = new Set(modifiedSettings);
+
+            // Remove the saved setting from modifiedSettings since it's now saved
+            setModifiedSettings((prev) => {
+              const updated = new Set(prev);
+              updated.delete(key);
+              return updated;
+            });
+
+            // Remove from modifiedValues as well
+            setModifiedValues((prev) => {
+              const updated = new Map(prev);
+              updated.delete(key);
+              return updated;
+            });
+
+            // Also remove from restart-required settings if it was there
+            setRestartRequiredSettings((prev) => {
+              const updated = new Set(prev);
+              updated.delete(key);
+              return updated;
+            });
+
+            setPendingSettings((_prevPending) => {
+              let updatedPending = structuredClone(
+                settings.forScope(selectedScope).settings,
+              );
+
+              currentModifiedSettings.forEach((modifiedKey) => {
+                if (modifiedKey !== key) {
+                  const modifiedValue = modifiedValues.get(modifiedKey);
+                  if (modifiedValue !== undefined) {
+                    updatedPending = setPendingSettingValue(
+                      modifiedKey,
+                      modifiedValue,
+                      updatedPending,
+                    );
+                  }
+                }
+              });
+
+              return updatedPending;
+            });
+          } else {
+            // For restart-required settings, store the actual value
+            setModifiedValues((prev) => {
+              const updated = new Map(prev);
+              updated.set(key, newValue);
+              return updated;
+            });
+
+            setModifiedSettings((prev) => {
+              const updated = new Set(prev).add(key);
+              const needsRestart = hasRestartRequiredSettings(updated);
+              console.log(
+                `[DEBUG SettingsDialog] Modified settings:`,
+                Array.from(updated),
+                'Needs restart:',
+                needsRestart,
+              );
+              if (needsRestart) {
+                setShowRestartPrompt(true);
+                setRestartRequiredSettings((prevRestart) =>
+                  new Set(prevRestart).add(key),
+                );
+              }
+              return updated;
+            });
+          }
+        },
+      };
+    });
+  };
+
+  const items = generateSettingsItems();
+
+  // Scope selector items
+  const scopeItems = getScopeItems();
+
+  const handleScopeHighlight = (scope: SettingScope) => {
+    setSelectedScope(scope);
+  };
+
+  const handleScopeSelect = (scope: SettingScope) => {
+    handleScopeHighlight(scope);
+    setFocusSection('settings');
+  };
+
+  // Scroll logic for settings
+  const visibleItems = items.slice(scrollOffset, scrollOffset + maxItemsToShow);
+  // Always show arrows for consistent UI and to indicate circular navigation
+  const showScrollUp = true;
+  const showScrollDown = true;
+
+  useInput((input, key) => {
+    if (key.tab) {
+      setFocusSection((prev) => (prev === 'settings' ? 'scope' : 'settings'));
+    }
+    if (focusSection === 'settings') {
+      if (key.upArrow || input === 'k') {
+        const newIndex =
+          activeSettingIndex > 0 ? activeSettingIndex - 1 : items.length - 1;
+        setActiveSettingIndex(newIndex);
+        // Adjust scroll offset for wrap-around
+        if (newIndex === items.length - 1) {
+          setScrollOffset(Math.max(0, items.length - maxItemsToShow));
+        } else if (newIndex < scrollOffset) {
+          setScrollOffset(newIndex);
+        }
+      } else if (key.downArrow || input === 'j') {
+        const newIndex =
+          activeSettingIndex < items.length - 1 ? activeSettingIndex + 1 : 0;
+        setActiveSettingIndex(newIndex);
+        // Adjust scroll offset for wrap-around
+        if (newIndex === 0) {
+          setScrollOffset(0);
+        } else if (newIndex >= scrollOffset + maxItemsToShow) {
+          setScrollOffset(newIndex - maxItemsToShow + 1);
+        }
+      } else if (key.return || input === ' ') {
+        items[activeSettingIndex]?.toggle();
+      } else if ((key.ctrl && input === 'c') || (key.ctrl && input === 'l')) {
+        // Ctrl+C or Ctrl+L: Clear current setting and reset to default
+        const currentSetting = items[activeSettingIndex];
+        if (currentSetting) {
+          const defaultValue = getDefaultValue(currentSetting.value);
+          // Ensure defaultValue is a boolean for setPendingSettingValue
+          const booleanDefaultValue =
+            typeof defaultValue === 'boolean' ? defaultValue : false;
+
+          // Update pending settings to default value
+          setPendingSettings((prev) =>
+            setPendingSettingValue(
+              currentSetting.value,
+              booleanDefaultValue,
+              prev,
+            ),
+          );
+
+          // Remove from modified settings since it's now at default
+          setModifiedSettings((prev) => {
+            const updated = new Set(prev);
+            updated.delete(currentSetting.value);
+            return updated;
+          });
+
+          // Remove from restart-required settings if it was there
+          setRestartRequiredSettings((prev) => {
+            const updated = new Set(prev);
+            updated.delete(currentSetting.value);
+            return updated;
+          });
+
+          // If this setting doesn't require restart, save it immediately
+          if (!requiresRestart(currentSetting.value)) {
+            const immediateSettings = new Set([currentSetting.value]);
+            const immediateSettingsObject = setPendingSettingValue(
+              currentSetting.value,
+              booleanDefaultValue,
+              {},
+            );
+
+            saveModifiedSettings(
+              immediateSettings,
+              immediateSettingsObject,
+              settings,
+              selectedScope,
+            );
+          }
+        }
+      }
+    }
+    if (showRestartPrompt && input === 'r') {
+      // Only save settings that require restart (non-restart settings were already saved immediately)
+      const restartRequiredSettings =
+        getRestartRequiredFromModified(modifiedSettings);
+      const restartRequiredSet = new Set(restartRequiredSettings);
+
+      if (restartRequiredSet.size > 0) {
+        saveModifiedSettings(
+          restartRequiredSet,
+          pendingSettings,
+          settings,
+          selectedScope,
+        );
+      }
+
+      setShowRestartPrompt(false);
+      setRestartRequiredSettings(new Set()); // Clear restart-required settings
+      if (onRestartRequest) onRestartRequest();
+    }
+    if (key.escape) {
+      onSelect(undefined, selectedScope);
+    }
+  });
+
+  return (
+    <Box
+      borderStyle="round"
+      borderColor={Colors.Gray}
+      flexDirection="row"
+      padding={1}
+      width="100%"
+      height="100%"
+    >
+      <Box flexDirection="column" flexGrow={1}>
+        <Text bold color={Colors.AccentBlue}>
+          Settings
+        </Text>
+        <Box height={1} />
+        {showScrollUp && <Text color={Colors.Gray}>▲</Text>}
+        {visibleItems.map((item, idx) => {
+          const isActive =
+            focusSection === 'settings' &&
+            activeSettingIndex === idx + scrollOffset;
+
+          const scopeSettings = settings.forScope(selectedScope).settings;
+          const mergedSettings = settings.merged;
+          const displayValue = getDisplayValue(
+            item.value,
+            scopeSettings,
+            mergedSettings,
+            modifiedSettings,
+            pendingSettings,
+          );
+          const shouldBeGreyedOut = isDefaultValue(item.value, scopeSettings);
+
+          // Generate scope message for this setting
+          const scopeMessage = getScopeMessageForSetting(
+            item.value,
+            selectedScope,
+            settings,
+          );
+
+          return (
+            <React.Fragment key={item.value}>
+              <Box flexDirection="row" alignItems="center">
+                <Box minWidth={2} flexShrink={0}>
+                  <Text color={isActive ? Colors.AccentGreen : Colors.Gray}>
+                    {isActive ? '●' : ''}
+                  </Text>
+                </Box>
+                <Box minWidth={50}>
+                  <Text
+                    color={isActive ? Colors.AccentGreen : Colors.Foreground}
+                  >
+                    {item.label}
+                    {scopeMessage && (
+                      <Text color={Colors.Gray}> {scopeMessage}</Text>
+                    )}
+                  </Text>
+                </Box>
+                <Box minWidth={3} />
+                <Text
+                  color={
+                    isActive
+                      ? Colors.AccentGreen
+                      : shouldBeGreyedOut
+                        ? Colors.Gray
+                        : Colors.Foreground
+                  }
+                >
+                  {displayValue}
+                </Text>
+              </Box>
+              <Box height={1} />
+            </React.Fragment>
+          );
+        })}
+        {showScrollDown && <Text color={Colors.Gray}>▼</Text>}
+
+        <Box height={1} />
+
+        <Box marginTop={1} flexDirection="column">
+          <Text bold={focusSection === 'scope'} wrap="truncate">
+            {focusSection === 'scope' ? '> ' : '  '}Apply To
+          </Text>
+          <RadioButtonSelect
+            items={scopeItems}
+            initialIndex={0}
+            onSelect={handleScopeSelect}
+            onHighlight={handleScopeHighlight}
+            isFocused={focusSection === 'scope'}
+            showNumbers={focusSection === 'scope'}
+          />
+        </Box>
+
+        <Box height={1} />
+        <Text color={Colors.Gray}>
+          (Use Enter to select, Tab to change focus)
+        </Text>
+        {showRestartPrompt && (
+          <Text color={Colors.AccentYellow}>
+            To see changes, Gemini CLI must be restarted. Press r to exit and
+            apply changes now.
+          </Text>
+        )}
+      </Box>
+    </Box>
+  );
+}
diff --git a/packages/cli/src/ui/components/ThemeDialog.tsx b/packages/cli/src/ui/components/ThemeDialog.tsx
index 7c38bb4b..37663447 100644
--- a/packages/cli/src/ui/components/ThemeDialog.tsx
+++ b/packages/cli/src/ui/components/ThemeDialog.tsx
@@ -12,6 +12,10 @@ import { RadioButtonSelect } from './shared/RadioButtonSelect.js';
 import { DiffRenderer } from './messages/DiffRenderer.js';
 import { colorizeCode } from '../utils/CodeColorizer.js';
 import { LoadedSettings, SettingScope } from '../../config/settings.js';
+import {
+  getScopeItems,
+  getScopeMessageForSetting,
+} from '../../utils/dialogScopeUtils.js';
 
 interface ThemeDialogProps {
   /** Callback function when a theme is selected */
@@ -76,11 +80,7 @@ export function ThemeDialog({
   // If not found, fall back to the first theme
   const safeInitialThemeIndex = initialThemeIndex >= 0 ? initialThemeIndex : 0;
 
-  const scopeItems = [
-    { label: 'User Settings', value: SettingScope.User },
-    { label: 'Workspace Settings', value: SettingScope.Workspace },
-    { label: 'System Settings', value: SettingScope.System },
-  ];
+  const scopeItems = getScopeItems();
 
   const handleThemeSelect = useCallback(
     (themeName: string) => {
@@ -120,23 +120,13 @@ export function ThemeDialog({
     }
   });
 
-  const otherScopes = Object.values(SettingScope).filter(
-    (scope) => scope !== selectedScope,
+  // Generate scope message for theme setting
+  const otherScopeModifiedMessage = getScopeMessageForSetting(
+    'theme',
+    selectedScope,
+    settings,
   );
 
-  const modifiedInOtherScopes = otherScopes.filter(
-    (scope) => settings.forScope(scope).settings.theme !== undefined,
-  );
-
-  let otherScopeModifiedMessage = '';
-  if (modifiedInOtherScopes.length > 0) {
-    const modifiedScopesStr = modifiedInOtherScopes.join(', ');
-    otherScopeModifiedMessage =
-      settings.forScope(selectedScope).settings.theme !== undefined
-        ? `(Also modified in ${modifiedScopesStr})`
-        : `(Modified in ${modifiedScopesStr})`;
-  }
-
   // Constants for calculating preview pane layout.
   // These values are based on the JSX structure below.
   const PREVIEW_PANE_WIDTH_PERCENTAGE = 0.55;
diff --git a/packages/cli/src/ui/hooks/slashCommandProcessor.test.ts b/packages/cli/src/ui/hooks/slashCommandProcessor.test.ts
index 37407689..66c1b883 100644
--- a/packages/cli/src/ui/hooks/slashCommandProcessor.test.ts
+++ b/packages/cli/src/ui/hooks/slashCommandProcessor.test.ts
@@ -147,6 +147,7 @@ describe('useSlashCommandProcessor', () => {
         vi.fn(), // toggleCorgiMode
         mockSetQuittingMessages,
         vi.fn(), // openPrivacyNotice
+        vi.fn(), // openSettingsDialog
         vi.fn(), // toggleVimEnabled
         setIsProcessing,
       ),
@@ -864,6 +865,9 @@ describe('useSlashCommandProcessor', () => {
           vi.fn(), // toggleCorgiMode
           mockSetQuittingMessages,
           vi.fn(), // openPrivacyNotice
+
+          vi.fn(), // openSettingsDialog
+          vi.fn(), // toggleVimEnabled
           vi.fn().mockResolvedValue(false), // toggleVimEnabled
           vi.fn(), // setIsProcessing
         ),
diff --git a/packages/cli/src/ui/hooks/slashCommandProcessor.ts b/packages/cli/src/ui/hooks/slashCommandProcessor.ts
index ca08abb1..b4ce0d4d 100644
--- a/packages/cli/src/ui/hooks/slashCommandProcessor.ts
+++ b/packages/cli/src/ui/hooks/slashCommandProcessor.ts
@@ -50,6 +50,7 @@ export const useSlashCommandProcessor = (
   toggleCorgiMode: () => void,
   setQuittingMessages: (message: HistoryItem[]) => void,
   openPrivacyNotice: () => void,
+  openSettingsDialog: () => void,
   toggleVimEnabled: () => Promise<boolean>,
   setIsProcessing: (isProcessing: boolean) => void,
   setGeminiMdFileCount: (count: number) => void,
@@ -359,6 +360,11 @@ export const useSlashCommandProcessor = (
                     case 'privacy':
                       openPrivacyNotice();
                       return { type: 'handled' };
+                    case 'settings':
+                      openSettingsDialog();
+                      return { type: 'handled' };
+                    case 'help':
+                      return { type: 'handled' };
                     default: {
                       const unhandled: never = result.dialog;
                       throw new Error(
@@ -512,6 +518,7 @@ export const useSlashCommandProcessor = (
       openPrivacyNotice,
       openEditorDialog,
       setQuittingMessages,
+      openSettingsDialog,
       setShellConfirmationRequest,
       setSessionShellAllowlist,
       setIsProcessing,
diff --git a/packages/cli/src/ui/hooks/useSettingsCommand.ts b/packages/cli/src/ui/hooks/useSettingsCommand.ts
new file mode 100644
index 00000000..42f535df
--- /dev/null
+++ b/packages/cli/src/ui/hooks/useSettingsCommand.ts
@@ -0,0 +1,25 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { useState, useCallback } from 'react';
+
+export function useSettingsCommand() {
+  const [isSettingsDialogOpen, setIsSettingsDialogOpen] = useState(false);
+
+  const openSettingsDialog = useCallback(() => {
+    setIsSettingsDialogOpen(true);
+  }, []);
+
+  const closeSettingsDialog = useCallback(() => {
+    setIsSettingsDialogOpen(false);
+  }, []);
+
+  return {
+    isSettingsDialogOpen,
+    openSettingsDialog,
+    closeSettingsDialog,
+  };
+}
diff --git a/packages/cli/src/utils/dialogScopeUtils.ts b/packages/cli/src/utils/dialogScopeUtils.ts
new file mode 100644
index 00000000..c175f9c8
--- /dev/null
+++ b/packages/cli/src/utils/dialogScopeUtils.ts
@@ -0,0 +1,64 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { SettingScope, LoadedSettings } from '../config/settings.js';
+import { settingExistsInScope } from './settingsUtils.js';
+
+/**
+ * Shared scope labels for dialog components that need to display setting scopes
+ */
+export const SCOPE_LABELS = {
+  [SettingScope.User]: 'User Settings',
+  [SettingScope.Workspace]: 'Workspace Settings',
+  [SettingScope.System]: 'System Settings',
+} as const;
+
+/**
+ * Helper function to get scope items for radio button selects
+ */
+export function getScopeItems() {
+  return [
+    { label: SCOPE_LABELS[SettingScope.User], value: SettingScope.User },
+    {
+      label: SCOPE_LABELS[SettingScope.Workspace],
+      value: SettingScope.Workspace,
+    },
+    { label: SCOPE_LABELS[SettingScope.System], value: SettingScope.System },
+  ];
+}
+
+/**
+ * Generate scope message for a specific setting
+ */
+export function getScopeMessageForSetting(
+  settingKey: string,
+  selectedScope: SettingScope,
+  settings: LoadedSettings,
+): string {
+  const otherScopes = Object.values(SettingScope).filter(
+    (scope) => scope !== selectedScope,
+  );
+
+  const modifiedInOtherScopes = otherScopes.filter((scope) => {
+    const scopeSettings = settings.forScope(scope).settings;
+    return settingExistsInScope(settingKey, scopeSettings);
+  });
+
+  if (modifiedInOtherScopes.length === 0) {
+    return '';
+  }
+
+  const modifiedScopesStr = modifiedInOtherScopes.join(', ');
+  const currentScopeSettings = settings.forScope(selectedScope).settings;
+  const existsInCurrentScope = settingExistsInScope(
+    settingKey,
+    currentScopeSettings,
+  );
+
+  return existsInCurrentScope
+    ? `(Also modified in ${modifiedScopesStr})`
+    : `(Modified in ${modifiedScopesStr})`;
+}
diff --git a/packages/cli/src/utils/settingsUtils.test.ts b/packages/cli/src/utils/settingsUtils.test.ts
new file mode 100644
index 00000000..2aeb1da3
--- /dev/null
+++ b/packages/cli/src/utils/settingsUtils.test.ts
@@ -0,0 +1,797 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { describe, it, expect } from 'vitest';
+import {
+  // Schema utilities
+  getSettingsByCategory,
+  getSettingDefinition,
+  requiresRestart,
+  getDefaultValue,
+  getRestartRequiredSettings,
+  getEffectiveValue,
+  getAllSettingKeys,
+  getSettingsByType,
+  getSettingsRequiringRestart,
+  isValidSettingKey,
+  getSettingCategory,
+  shouldShowInDialog,
+  getDialogSettingsByCategory,
+  getDialogSettingsByType,
+  getDialogSettingKeys,
+  // Business logic utilities
+  getSettingValue,
+  isSettingModified,
+  settingExistsInScope,
+  setPendingSettingValue,
+  hasRestartRequiredSettings,
+  getRestartRequiredFromModified,
+  getDisplayValue,
+  isDefaultValue,
+  isValueInherited,
+  getEffectiveDisplayValue,
+} from './settingsUtils.js';
+
+describe('SettingsUtils', () => {
+  describe('Schema Utilities', () => {
+    describe('getSettingsByCategory', () => {
+      it('should group settings by category', () => {
+        const categories = getSettingsByCategory();
+
+        expect(categories).toHaveProperty('General');
+        expect(categories).toHaveProperty('Accessibility');
+        expect(categories).toHaveProperty('Checkpointing');
+        expect(categories).toHaveProperty('File Filtering');
+        expect(categories).toHaveProperty('UI');
+        expect(categories).toHaveProperty('Mode');
+        expect(categories).toHaveProperty('Updates');
+      });
+
+      it('should include key property in grouped settings', () => {
+        const categories = getSettingsByCategory();
+
+        Object.entries(categories).forEach(([_category, settings]) => {
+          settings.forEach((setting) => {
+            expect(setting.key).toBeDefined();
+          });
+        });
+      });
+    });
+
+    describe('getSettingDefinition', () => {
+      it('should return definition for valid setting', () => {
+        const definition = getSettingDefinition('showMemoryUsage');
+        expect(definition).toBeDefined();
+        expect(definition?.label).toBe('Show Memory Usage');
+      });
+
+      it('should return undefined for invalid setting', () => {
+        const definition = getSettingDefinition('invalidSetting');
+        expect(definition).toBeUndefined();
+      });
+    });
+
+    describe('requiresRestart', () => {
+      it('should return true for settings that require restart', () => {
+        expect(requiresRestart('autoConfigureMaxOldSpaceSize')).toBe(true);
+        expect(requiresRestart('checkpointing.enabled')).toBe(true);
+      });
+
+      it('should return false for settings that do not require restart', () => {
+        expect(requiresRestart('showMemoryUsage')).toBe(false);
+        expect(requiresRestart('hideTips')).toBe(false);
+      });
+
+      it('should return false for invalid settings', () => {
+        expect(requiresRestart('invalidSetting')).toBe(false);
+      });
+    });
+
+    describe('getDefaultValue', () => {
+      it('should return correct default values', () => {
+        expect(getDefaultValue('showMemoryUsage')).toBe(false);
+        expect(getDefaultValue('fileFiltering.enableRecursiveFileSearch')).toBe(
+          true,
+        );
+      });
+
+      it('should return undefined for invalid settings', () => {
+        expect(getDefaultValue('invalidSetting')).toBeUndefined();
+      });
+    });
+
+    describe('getRestartRequiredSettings', () => {
+      it('should return all settings that require restart', () => {
+        const restartSettings = getRestartRequiredSettings();
+        expect(restartSettings).toContain('autoConfigureMaxOldSpaceSize');
+        expect(restartSettings).toContain('checkpointing.enabled');
+        expect(restartSettings).not.toContain('showMemoryUsage');
+      });
+    });
+
+    describe('getEffectiveValue', () => {
+      it('should return value from settings when set', () => {
+        const settings = { showMemoryUsage: true };
+        const mergedSettings = { showMemoryUsage: false };
+
+        const value = getEffectiveValue(
+          'showMemoryUsage',
+          settings,
+          mergedSettings,
+        );
+        expect(value).toBe(true);
+      });
+
+      it('should return value from merged settings when not set in current scope', () => {
+        const settings = {};
+        const mergedSettings = { showMemoryUsage: true };
+
+        const value = getEffectiveValue(
+          'showMemoryUsage',
+          settings,
+          mergedSettings,
+        );
+        expect(value).toBe(true);
+      });
+
+      it('should return default value when not set anywhere', () => {
+        const settings = {};
+        const mergedSettings = {};
+
+        const value = getEffectiveValue(
+          'showMemoryUsage',
+          settings,
+          mergedSettings,
+        );
+        expect(value).toBe(false); // default value
+      });
+
+      it('should handle nested settings correctly', () => {
+        const settings = {
+          accessibility: { disableLoadingPhrases: true },
+        };
+        const mergedSettings = {
+          accessibility: { disableLoadingPhrases: false },
+        };
+
+        const value = getEffectiveValue(
+          'accessibility.disableLoadingPhrases',
+          settings,
+          mergedSettings,
+        );
+        expect(value).toBe(true);
+      });
+
+      it('should return undefined for invalid settings', () => {
+        const settings = {};
+        const mergedSettings = {};
+
+        const value = getEffectiveValue(
+          'invalidSetting',
+          settings,
+          mergedSettings,
+        );
+        expect(value).toBeUndefined();
+      });
+    });
+
+    describe('getAllSettingKeys', () => {
+      it('should return all setting keys', () => {
+        const keys = getAllSettingKeys();
+        expect(keys).toContain('showMemoryUsage');
+        expect(keys).toContain('accessibility.disableLoadingPhrases');
+        expect(keys).toContain('checkpointing.enabled');
+      });
+    });
+
+    describe('getSettingsByType', () => {
+      it('should return only boolean settings', () => {
+        const booleanSettings = getSettingsByType('boolean');
+        expect(booleanSettings.length).toBeGreaterThan(0);
+        booleanSettings.forEach((setting) => {
+          expect(setting.type).toBe('boolean');
+        });
+      });
+    });
+
+    describe('getSettingsRequiringRestart', () => {
+      it('should return only settings that require restart', () => {
+        const restartSettings = getSettingsRequiringRestart();
+        expect(restartSettings.length).toBeGreaterThan(0);
+        restartSettings.forEach((setting) => {
+          expect(setting.requiresRestart).toBe(true);
+        });
+      });
+    });
+
+    describe('isValidSettingKey', () => {
+      it('should return true for valid setting keys', () => {
+        expect(isValidSettingKey('showMemoryUsage')).toBe(true);
+        expect(isValidSettingKey('accessibility.disableLoadingPhrases')).toBe(
+          true,
+        );
+      });
+
+      it('should return false for invalid setting keys', () => {
+        expect(isValidSettingKey('invalidSetting')).toBe(false);
+        expect(isValidSettingKey('')).toBe(false);
+      });
+    });
+
+    describe('getSettingCategory', () => {
+      it('should return correct category for valid settings', () => {
+        expect(getSettingCategory('showMemoryUsage')).toBe('UI');
+        expect(getSettingCategory('accessibility.disableLoadingPhrases')).toBe(
+          'Accessibility',
+        );
+      });
+
+      it('should return undefined for invalid settings', () => {
+        expect(getSettingCategory('invalidSetting')).toBeUndefined();
+      });
+    });
+
+    describe('shouldShowInDialog', () => {
+      it('should return true for settings marked to show in dialog', () => {
+        expect(shouldShowInDialog('showMemoryUsage')).toBe(true);
+        expect(shouldShowInDialog('vimMode')).toBe(true);
+        expect(shouldShowInDialog('hideWindowTitle')).toBe(true);
+        expect(shouldShowInDialog('usageStatisticsEnabled')).toBe(true);
+      });
+
+      it('should return false for settings marked to hide from dialog', () => {
+        expect(shouldShowInDialog('selectedAuthType')).toBe(false);
+        expect(shouldShowInDialog('coreTools')).toBe(false);
+        expect(shouldShowInDialog('customThemes')).toBe(false);
+        expect(shouldShowInDialog('theme')).toBe(false); // Changed to false
+        expect(shouldShowInDialog('preferredEditor')).toBe(false); // Changed to false
+      });
+
+      it('should return true for invalid settings (default behavior)', () => {
+        expect(shouldShowInDialog('invalidSetting')).toBe(true);
+      });
+    });
+
+    describe('getDialogSettingsByCategory', () => {
+      it('should only return settings marked for dialog display', async () => {
+        const categories = getDialogSettingsByCategory();
+
+        // Should include UI settings that are marked for dialog
+        expect(categories['UI']).toBeDefined();
+        const uiSettings = categories['UI'];
+        const uiKeys = uiSettings.map((s) => s.key);
+        expect(uiKeys).toContain('showMemoryUsage');
+        expect(uiKeys).toContain('hideWindowTitle');
+        expect(uiKeys).not.toContain('customThemes'); // This is marked false
+        expect(uiKeys).not.toContain('theme'); // This is now marked false
+      });
+
+      it('should not include Advanced category settings', () => {
+        const categories = getDialogSettingsByCategory();
+
+        // Advanced settings should be filtered out
+        expect(categories['Advanced']).toBeUndefined();
+      });
+
+      it('should include settings with showInDialog=true', () => {
+        const categories = getDialogSettingsByCategory();
+
+        const allSettings = Object.values(categories).flat();
+        const allKeys = allSettings.map((s) => s.key);
+
+        expect(allKeys).toContain('vimMode');
+        expect(allKeys).toContain('ideMode');
+        expect(allKeys).toContain('disableAutoUpdate');
+        expect(allKeys).toContain('showMemoryUsage');
+        expect(allKeys).toContain('usageStatisticsEnabled');
+        expect(allKeys).not.toContain('selectedAuthType');
+        expect(allKeys).not.toContain('coreTools');
+        expect(allKeys).not.toContain('theme'); // Now hidden
+        expect(allKeys).not.toContain('preferredEditor'); // Now hidden
+      });
+    });
+
+    describe('getDialogSettingsByType', () => {
+      it('should return only boolean dialog settings', () => {
+        const booleanSettings = getDialogSettingsByType('boolean');
+
+        const keys = booleanSettings.map((s) => s.key);
+        expect(keys).toContain('showMemoryUsage');
+        expect(keys).toContain('vimMode');
+        expect(keys).toContain('hideWindowTitle');
+        expect(keys).toContain('usageStatisticsEnabled');
+        expect(keys).not.toContain('selectedAuthType'); // Advanced setting
+        expect(keys).not.toContain('useExternalAuth'); // Advanced setting
+      });
+
+      it('should return only string dialog settings', () => {
+        const stringSettings = getDialogSettingsByType('string');
+
+        const keys = stringSettings.map((s) => s.key);
+        // Note: theme and preferredEditor are now hidden from dialog
+        expect(keys).not.toContain('theme'); // Now marked false
+        expect(keys).not.toContain('preferredEditor'); // Now marked false
+        expect(keys).not.toContain('selectedAuthType'); // Advanced setting
+
+        // Most string settings are now hidden, so let's just check they exclude advanced ones
+        expect(keys.every((key) => !key.startsWith('tool'))).toBe(true); // No tool-related settings
+      });
+    });
+
+    describe('getDialogSettingKeys', () => {
+      it('should return only settings marked for dialog display', () => {
+        const dialogKeys = getDialogSettingKeys();
+
+        // Should include settings marked for dialog
+        expect(dialogKeys).toContain('showMemoryUsage');
+        expect(dialogKeys).toContain('vimMode');
+        expect(dialogKeys).toContain('hideWindowTitle');
+        expect(dialogKeys).toContain('usageStatisticsEnabled');
+        expect(dialogKeys).toContain('ideMode');
+        expect(dialogKeys).toContain('disableAutoUpdate');
+
+        // Should include nested settings marked for dialog
+        expect(dialogKeys).toContain('fileFiltering.respectGitIgnore');
+        expect(dialogKeys).toContain('fileFiltering.respectGeminiIgnore');
+        expect(dialogKeys).toContain('fileFiltering.enableRecursiveFileSearch');
+
+        // Should NOT include settings marked as hidden
+        expect(dialogKeys).not.toContain('theme'); // Hidden
+        expect(dialogKeys).not.toContain('customThemes'); // Hidden
+        expect(dialogKeys).not.toContain('preferredEditor'); // Hidden
+        expect(dialogKeys).not.toContain('selectedAuthType'); // Advanced
+        expect(dialogKeys).not.toContain('coreTools'); // Advanced
+        expect(dialogKeys).not.toContain('mcpServers'); // Advanced
+        expect(dialogKeys).not.toContain('telemetry'); // Advanced
+      });
+
+      it('should return fewer keys than getAllSettingKeys', () => {
+        const allKeys = getAllSettingKeys();
+        const dialogKeys = getDialogSettingKeys();
+
+        expect(dialogKeys.length).toBeLessThan(allKeys.length);
+        expect(dialogKeys.length).toBeGreaterThan(0);
+      });
+
+      it('should handle nested settings display correctly', () => {
+        // Test the specific issue with fileFiltering.respectGitIgnore
+        const key = 'fileFiltering.respectGitIgnore';
+        const initialSettings = {};
+        const pendingSettings = {};
+
+        // Set the nested setting to true
+        const updatedPendingSettings = setPendingSettingValue(
+          key,
+          true,
+          pendingSettings,
+        );
+
+        // Check if the setting exists in pending settings
+        const existsInPending = settingExistsInScope(
+          key,
+          updatedPendingSettings,
+        );
+        expect(existsInPending).toBe(true);
+
+        // Get the value from pending settings
+        const valueFromPending = getSettingValue(
+          key,
+          updatedPendingSettings,
+          {},
+        );
+        expect(valueFromPending).toBe(true);
+
+        // Test getDisplayValue should show the pending change
+        const displayValue = getDisplayValue(
+          key,
+          initialSettings,
+          {},
+          new Set(),
+          updatedPendingSettings,
+        );
+        expect(displayValue).toBe('true*'); // Should show true with * indicating change
+
+        // Test that modified settings also show the * indicator
+        const modifiedSettings = new Set([key]);
+        const displayValueWithModified = getDisplayValue(
+          key,
+          initialSettings,
+          {},
+          modifiedSettings,
+          {},
+        );
+        expect(displayValueWithModified).toBe('true*'); // Should show true* because it's in modified settings and default is true
+      });
+    });
+  });
+
+  describe('Business Logic Utilities', () => {
+    describe('getSettingValue', () => {
+      it('should return value from settings when set', () => {
+        const settings = { showMemoryUsage: true };
+        const mergedSettings = { showMemoryUsage: false };
+
+        const value = getSettingValue(
+          'showMemoryUsage',
+          settings,
+          mergedSettings,
+        );
+        expect(value).toBe(true);
+      });
+
+      it('should return value from merged settings when not set in current scope', () => {
+        const settings = {};
+        const mergedSettings = { showMemoryUsage: true };
+
+        const value = getSettingValue(
+          'showMemoryUsage',
+          settings,
+          mergedSettings,
+        );
+        expect(value).toBe(true);
+      });
+
+      it('should return default value for invalid setting', () => {
+        const settings = {};
+        const mergedSettings = {};
+
+        const value = getSettingValue(
+          'invalidSetting',
+          settings,
+          mergedSettings,
+        );
+        expect(value).toBe(false); // Default fallback
+      });
+    });
+
+    describe('isSettingModified', () => {
+      it('should return true when value differs from default', () => {
+        expect(isSettingModified('showMemoryUsage', true)).toBe(true);
+        expect(
+          isSettingModified('fileFiltering.enableRecursiveFileSearch', false),
+        ).toBe(true);
+      });
+
+      it('should return false when value matches default', () => {
+        expect(isSettingModified('showMemoryUsage', false)).toBe(false);
+        expect(
+          isSettingModified('fileFiltering.enableRecursiveFileSearch', true),
+        ).toBe(false);
+      });
+    });
+
+    describe('settingExistsInScope', () => {
+      it('should return true for top-level settings that exist', () => {
+        const settings = { showMemoryUsage: true };
+        expect(settingExistsInScope('showMemoryUsage', settings)).toBe(true);
+      });
+
+      it('should return false for top-level settings that do not exist', () => {
+        const settings = {};
+        expect(settingExistsInScope('showMemoryUsage', settings)).toBe(false);
+      });
+
+      it('should return true for nested settings that exist', () => {
+        const settings = {
+          accessibility: { disableLoadingPhrases: true },
+        };
+        expect(
+          settingExistsInScope('accessibility.disableLoadingPhrases', settings),
+        ).toBe(true);
+      });
+
+      it('should return false for nested settings that do not exist', () => {
+        const settings = {};
+        expect(
+          settingExistsInScope('accessibility.disableLoadingPhrases', settings),
+        ).toBe(false);
+      });
+
+      it('should return false when parent exists but child does not', () => {
+        const settings = { accessibility: {} };
+        expect(
+          settingExistsInScope('accessibility.disableLoadingPhrases', settings),
+        ).toBe(false);
+      });
+    });
+
+    describe('setPendingSettingValue', () => {
+      it('should set top-level setting value', () => {
+        const pendingSettings = {};
+        const result = setPendingSettingValue(
+          'showMemoryUsage',
+          true,
+          pendingSettings,
+        );
+
+        expect(result.showMemoryUsage).toBe(true);
+      });
+
+      it('should set nested setting value', () => {
+        const pendingSettings = {};
+        const result = setPendingSettingValue(
+          'accessibility.disableLoadingPhrases',
+          true,
+          pendingSettings,
+        );
+
+        expect(result.accessibility?.disableLoadingPhrases).toBe(true);
+      });
+
+      it('should preserve existing nested settings', () => {
+        const pendingSettings = {
+          accessibility: { disableLoadingPhrases: false },
+        };
+        const result = setPendingSettingValue(
+          'accessibility.disableLoadingPhrases',
+          true,
+          pendingSettings,
+        );
+
+        expect(result.accessibility?.disableLoadingPhrases).toBe(true);
+      });
+
+      it('should not mutate original settings', () => {
+        const pendingSettings = {};
+        setPendingSettingValue('showMemoryUsage', true, pendingSettings);
+
+        expect(pendingSettings).toEqual({});
+      });
+    });
+
+    describe('hasRestartRequiredSettings', () => {
+      it('should return true when modified settings require restart', () => {
+        const modifiedSettings = new Set<string>([
+          'autoConfigureMaxOldSpaceSize',
+          'showMemoryUsage',
+        ]);
+        expect(hasRestartRequiredSettings(modifiedSettings)).toBe(true);
+      });
+
+      it('should return false when no modified settings require restart', () => {
+        const modifiedSettings = new Set<string>([
+          'showMemoryUsage',
+          'hideTips',
+        ]);
+        expect(hasRestartRequiredSettings(modifiedSettings)).toBe(false);
+      });
+
+      it('should return false for empty set', () => {
+        const modifiedSettings = new Set<string>();
+        expect(hasRestartRequiredSettings(modifiedSettings)).toBe(false);
+      });
+    });
+
+    describe('getRestartRequiredFromModified', () => {
+      it('should return only settings that require restart', () => {
+        const modifiedSettings = new Set<string>([
+          'autoConfigureMaxOldSpaceSize',
+          'showMemoryUsage',
+          'checkpointing.enabled',
+        ]);
+        const result = getRestartRequiredFromModified(modifiedSettings);
+
+        expect(result).toContain('autoConfigureMaxOldSpaceSize');
+        expect(result).toContain('checkpointing.enabled');
+        expect(result).not.toContain('showMemoryUsage');
+      });
+
+      it('should return empty array when no settings require restart', () => {
+        const modifiedSettings = new Set<string>([
+          'showMemoryUsage',
+          'hideTips',
+        ]);
+        const result = getRestartRequiredFromModified(modifiedSettings);
+
+        expect(result).toEqual([]);
+      });
+    });
+
+    describe('getDisplayValue', () => {
+      it('should show value without * when setting matches default', () => {
+        const settings = { showMemoryUsage: false }; // false matches default, so no *
+        const mergedSettings = { showMemoryUsage: false };
+        const modifiedSettings = new Set<string>();
+
+        const result = getDisplayValue(
+          'showMemoryUsage',
+          settings,
+          mergedSettings,
+          modifiedSettings,
+        );
+        expect(result).toBe('false'); // matches default, no *
+      });
+
+      it('should show default value when setting is not in scope', () => {
+        const settings = {}; // no setting in scope
+        const mergedSettings = { showMemoryUsage: false };
+        const modifiedSettings = new Set<string>();
+
+        const result = getDisplayValue(
+          'showMemoryUsage',
+          settings,
+          mergedSettings,
+          modifiedSettings,
+        );
+        expect(result).toBe('false'); // shows default value
+      });
+
+      it('should show value with * when changed from default', () => {
+        const settings = { showMemoryUsage: true }; // true is different from default (false)
+        const mergedSettings = { showMemoryUsage: true };
+        const modifiedSettings = new Set<string>();
+
+        const result = getDisplayValue(
+          'showMemoryUsage',
+          settings,
+          mergedSettings,
+          modifiedSettings,
+        );
+        expect(result).toBe('true*');
+      });
+
+      it('should show default value without * when setting does not exist in scope', () => {
+        const settings = {}; // setting doesn't exist in scope, show default
+        const mergedSettings = { showMemoryUsage: false };
+        const modifiedSettings = new Set<string>();
+
+        const result = getDisplayValue(
+          'showMemoryUsage',
+          settings,
+          mergedSettings,
+          modifiedSettings,
+        );
+        expect(result).toBe('false'); // default value (false) without *
+      });
+
+      it('should show value with * when user changes from default', () => {
+        const settings = {}; // setting doesn't exist in scope originally
+        const mergedSettings = { showMemoryUsage: false };
+        const modifiedSettings = new Set<string>(['showMemoryUsage']);
+        const pendingSettings = { showMemoryUsage: true }; // user changed to true
+
+        const result = getDisplayValue(
+          'showMemoryUsage',
+          settings,
+          mergedSettings,
+          modifiedSettings,
+          pendingSettings,
+        );
+        expect(result).toBe('true*'); // changed from default (false) to true
+      });
+    });
+
+    describe('isDefaultValue', () => {
+      it('should return true when setting does not exist in scope', () => {
+        const settings = {}; // setting doesn't exist
+
+        const result = isDefaultValue('showMemoryUsage', settings);
+        expect(result).toBe(true);
+      });
+
+      it('should return false when setting exists in scope', () => {
+        const settings = { showMemoryUsage: true }; // setting exists
+
+        const result = isDefaultValue('showMemoryUsage', settings);
+        expect(result).toBe(false);
+      });
+
+      it('should return true when nested setting does not exist in scope', () => {
+        const settings = {}; // nested setting doesn't exist
+
+        const result = isDefaultValue(
+          'accessibility.disableLoadingPhrases',
+          settings,
+        );
+        expect(result).toBe(true);
+      });
+
+      it('should return false when nested setting exists in scope', () => {
+        const settings = { accessibility: { disableLoadingPhrases: true } }; // nested setting exists
+
+        const result = isDefaultValue(
+          'accessibility.disableLoadingPhrases',
+          settings,
+        );
+        expect(result).toBe(false);
+      });
+    });
+
+    describe('isValueInherited', () => {
+      it('should return false for top-level settings that exist in scope', () => {
+        const settings = { showMemoryUsage: true };
+        const mergedSettings = { showMemoryUsage: true };
+
+        const result = isValueInherited(
+          'showMemoryUsage',
+          settings,
+          mergedSettings,
+        );
+        expect(result).toBe(false);
+      });
+
+      it('should return true for top-level settings that do not exist in scope', () => {
+        const settings = {};
+        const mergedSettings = { showMemoryUsage: true };
+
+        const result = isValueInherited(
+          'showMemoryUsage',
+          settings,
+          mergedSettings,
+        );
+        expect(result).toBe(true);
+      });
+
+      it('should return false for nested settings that exist in scope', () => {
+        const settings = {
+          accessibility: { disableLoadingPhrases: true },
+        };
+        const mergedSettings = {
+          accessibility: { disableLoadingPhrases: true },
+        };
+
+        const result = isValueInherited(
+          'accessibility.disableLoadingPhrases',
+          settings,
+          mergedSettings,
+        );
+        expect(result).toBe(false);
+      });
+
+      it('should return true for nested settings that do not exist in scope', () => {
+        const settings = {};
+        const mergedSettings = {
+          accessibility: { disableLoadingPhrases: true },
+        };
+
+        const result = isValueInherited(
+          'accessibility.disableLoadingPhrases',
+          settings,
+          mergedSettings,
+        );
+        expect(result).toBe(true);
+      });
+    });
+
+    describe('getEffectiveDisplayValue', () => {
+      it('should return value from settings when available', () => {
+        const settings = { showMemoryUsage: true };
+        const mergedSettings = { showMemoryUsage: false };
+
+        const result = getEffectiveDisplayValue(
+          'showMemoryUsage',
+          settings,
+          mergedSettings,
+        );
+        expect(result).toBe(true);
+      });
+
+      it('should return value from merged settings when not in scope', () => {
+        const settings = {};
+        const mergedSettings = { showMemoryUsage: true };
+
+        const result = getEffectiveDisplayValue(
+          'showMemoryUsage',
+          settings,
+          mergedSettings,
+        );
+        expect(result).toBe(true);
+      });
+
+      it('should return default value for undefined values', () => {
+        const settings = {};
+        const mergedSettings = {};
+
+        const result = getEffectiveDisplayValue(
+          'showMemoryUsage',
+          settings,
+          mergedSettings,
+        );
+        expect(result).toBe(false); // Default value
+      });
+    });
+  });
+});
diff --git a/packages/cli/src/utils/settingsUtils.ts b/packages/cli/src/utils/settingsUtils.ts
new file mode 100644
index 00000000..f4363400
--- /dev/null
+++ b/packages/cli/src/utils/settingsUtils.ts
@@ -0,0 +1,473 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { Settings, SettingScope, LoadedSettings } from '../config/settings.js';
+import {
+  SETTINGS_SCHEMA,
+  SettingDefinition,
+  SettingsSchema,
+} from '../config/settingsSchema.js';
+
+// The schema is now nested, but many parts of the UI and logic work better
+// with a flattened structure and dot-notation keys. This section flattens the
+// schema into a map for easier lookups.
+
+function flattenSchema(
+  schema: SettingsSchema,
+  prefix = '',
+): Record<string, SettingDefinition & { key: string }> {
+  let result: Record<string, SettingDefinition & { key: string }> = {};
+  for (const key in schema) {
+    const newKey = prefix ? `${prefix}.${key}` : key;
+    const definition = schema[key];
+    result[newKey] = { ...definition, key: newKey };
+    if (definition.properties) {
+      result = { ...result, ...flattenSchema(definition.properties, newKey) };
+    }
+  }
+  return result;
+}
+
+const FLATTENED_SCHEMA = flattenSchema(SETTINGS_SCHEMA);
+
+/**
+ * Get all settings grouped by category
+ */
+export function getSettingsByCategory(): Record<
+  string,
+  Array<SettingDefinition & { key: string }>
+> {
+  const categories: Record<
+    string,
+    Array<SettingDefinition & { key: string }>
+  > = {};
+
+  Object.values(FLATTENED_SCHEMA).forEach((definition) => {
+    const category = definition.category;
+    if (!categories[category]) {
+      categories[category] = [];
+    }
+    categories[category].push(definition);
+  });
+
+  return categories;
+}
+
+/**
+ * Get a setting definition by key
+ */
+export function getSettingDefinition(
+  key: string,
+): (SettingDefinition & { key: string }) | undefined {
+  return FLATTENED_SCHEMA[key];
+}
+
+/**
+ * Check if a setting requires restart
+ */
+export function requiresRestart(key: string): boolean {
+  return FLATTENED_SCHEMA[key]?.requiresRestart ?? false;
+}
+
+/**
+ * Get the default value for a setting
+ */
+export function getDefaultValue(key: string): SettingDefinition['default'] {
+  return FLATTENED_SCHEMA[key]?.default;
+}
+
+/**
+ * Get all setting keys that require restart
+ */
+export function getRestartRequiredSettings(): string[] {
+  return Object.values(FLATTENED_SCHEMA)
+    .filter((definition) => definition.requiresRestart)
+    .map((definition) => definition.key);
+}
+
+/**
+ * Recursively gets a value from a nested object using a key path array.
+ */
+function getNestedValue(obj: Record<string, unknown>, path: string[]): unknown {
+  const [first, ...rest] = path;
+  if (!first || !(first in obj)) {
+    return undefined;
+  }
+  const value = obj[first];
+  if (rest.length === 0) {
+    return value;
+  }
+  if (value && typeof value === 'object' && value !== null) {
+    return getNestedValue(value as Record<string, unknown>, rest);
+  }
+  return undefined;
+}
+
+/**
+ * Get the effective value for a setting, considering inheritance from higher scopes
+ * Always returns a value (never undefined) - falls back to default if not set anywhere
+ */
+export function getEffectiveValue(
+  key: string,
+  settings: Settings,
+  mergedSettings: Settings,
+): SettingDefinition['default'] {
+  const definition = getSettingDefinition(key);
+  if (!definition) {
+    return undefined;
+  }
+
+  const path = key.split('.');
+
+  // Check the current scope's settings first
+  let value = getNestedValue(settings as Record<string, unknown>, path);
+  if (value !== undefined) {
+    return value as SettingDefinition['default'];
+  }
+
+  // Check the merged settings for an inherited value
+  value = getNestedValue(mergedSettings as Record<string, unknown>, path);
+  if (value !== undefined) {
+    return value as SettingDefinition['default'];
+  }
+
+  // Return default value if no value is set anywhere
+  return definition.default;
+}
+
+/**
+ * Get all setting keys from the schema
+ */
+export function getAllSettingKeys(): string[] {
+  return Object.keys(FLATTENED_SCHEMA);
+}
+
+/**
+ * Get settings by type
+ */
+export function getSettingsByType(
+  type: SettingDefinition['type'],
+): Array<SettingDefinition & { key: string }> {
+  return Object.values(FLATTENED_SCHEMA).filter(
+    (definition) => definition.type === type,
+  );
+}
+
+/**
+ * Get settings that require restart
+ */
+export function getSettingsRequiringRestart(): Array<
+  SettingDefinition & {
+    key: string;
+  }
+> {
+  return Object.values(FLATTENED_SCHEMA).filter(
+    (definition) => definition.requiresRestart,
+  );
+}
+
+/**
+ * Validate if a setting key exists in the schema
+ */
+export function isValidSettingKey(key: string): boolean {
+  return key in FLATTENED_SCHEMA;
+}
+
+/**
+ * Get the category for a setting
+ */
+export function getSettingCategory(key: string): string | undefined {
+  return FLATTENED_SCHEMA[key]?.category;
+}
+
+/**
+ * Check if a setting should be shown in the settings dialog
+ */
+export function shouldShowInDialog(key: string): boolean {
+  return FLATTENED_SCHEMA[key]?.showInDialog ?? true; // Default to true for backward compatibility
+}
+
+/**
+ * Get all settings that should be shown in the dialog, grouped by category
+ */
+export function getDialogSettingsByCategory(): Record<
+  string,
+  Array<SettingDefinition & { key: string }>
+> {
+  const categories: Record<
+    string,
+    Array<SettingDefinition & { key: string }>
+  > = {};
+
+  Object.values(FLATTENED_SCHEMA)
+    .filter((definition) => definition.showInDialog !== false)
+    .forEach((definition) => {
+      const category = definition.category;
+      if (!categories[category]) {
+        categories[category] = [];
+      }
+      categories[category].push(definition);
+    });
+
+  return categories;
+}
+
+/**
+ * Get settings by type that should be shown in the dialog
+ */
+export function getDialogSettingsByType(
+  type: SettingDefinition['type'],
+): Array<SettingDefinition & { key: string }> {
+  return Object.values(FLATTENED_SCHEMA).filter(
+    (definition) =>
+      definition.type === type && definition.showInDialog !== false,
+  );
+}
+
+/**
+ * Get all setting keys that should be shown in the dialog
+ */
+export function getDialogSettingKeys(): string[] {
+  return Object.values(FLATTENED_SCHEMA)
+    .filter((definition) => definition.showInDialog !== false)
+    .map((definition) => definition.key);
+}
+
+// ============================================================================
+// BUSINESS LOGIC UTILITIES (Higher-level utilities for setting operations)
+// ============================================================================
+
+/**
+ * Get the current value for a setting in a specific scope
+ * Always returns a value (never undefined) - falls back to default if not set anywhere
+ */
+export function getSettingValue(
+  key: string,
+  settings: Settings,
+  mergedSettings: Settings,
+): boolean {
+  const definition = getSettingDefinition(key);
+  if (!definition) {
+    return false; // Default fallback for invalid settings
+  }
+
+  const value = getEffectiveValue(key, settings, mergedSettings);
+  // Ensure we return a boolean value, converting from the more general type
+  if (typeof value === 'boolean') {
+    return value;
+  }
+  // Fall back to default value, ensuring it's a boolean
+  const defaultValue = definition.default;
+  if (typeof defaultValue === 'boolean') {
+    return defaultValue;
+  }
+  return false; // Final fallback
+}
+
+/**
+ * Check if a setting value is modified from its default
+ */
+export function isSettingModified(key: string, value: boolean): boolean {
+  const defaultValue = getDefaultValue(key);
+  // Handle type comparison properly
+  if (typeof defaultValue === 'boolean') {
+    return value !== defaultValue;
+  }
+  // If default is not a boolean, consider it modified if value is true
+  return value === true;
+}
+
+/**
+ * Check if a setting exists in the original settings file for a scope
+ */
+export function settingExistsInScope(
+  key: string,
+  scopeSettings: Settings,
+): boolean {
+  const path = key.split('.');
+  const value = getNestedValue(scopeSettings as Record<string, unknown>, path);
+  return value !== undefined;
+}
+
+/**
+ * Recursively sets a value in a nested object using a key path array.
+ */
+function setNestedValue(
+  obj: Record<string, unknown>,
+  path: string[],
+  value: unknown,
+): Record<string, unknown> {
+  const [first, ...rest] = path;
+  if (!first) {
+    return obj;
+  }
+
+  if (rest.length === 0) {
+    obj[first] = value;
+    return obj;
+  }
+
+  if (!obj[first] || typeof obj[first] !== 'object') {
+    obj[first] = {};
+  }
+
+  setNestedValue(obj[first] as Record<string, unknown>, rest, value);
+  return obj;
+}
+
+/**
+ * Set a setting value in the pending settings
+ */
+export function setPendingSettingValue(
+  key: string,
+  value: boolean,
+  pendingSettings: Settings,
+): Settings {
+  const path = key.split('.');
+  const newSettings = JSON.parse(JSON.stringify(pendingSettings));
+  setNestedValue(newSettings, path, value);
+  return newSettings;
+}
+
+/**
+ * Check if any modified settings require a restart
+ */
+export function hasRestartRequiredSettings(
+  modifiedSettings: Set<string>,
+): boolean {
+  return Array.from(modifiedSettings).some((key) => requiresRestart(key));
+}
+
+/**
+ * Get the restart required settings from a set of modified settings
+ */
+export function getRestartRequiredFromModified(
+  modifiedSettings: Set<string>,
+): string[] {
+  return Array.from(modifiedSettings).filter((key) => requiresRestart(key));
+}
+
+/**
+ * Save modified settings to the appropriate scope
+ */
+export function saveModifiedSettings(
+  modifiedSettings: Set<string>,
+  pendingSettings: Settings,
+  loadedSettings: LoadedSettings,
+  scope: SettingScope,
+): void {
+  modifiedSettings.forEach((settingKey) => {
+    const path = settingKey.split('.');
+    const value = getNestedValue(
+      pendingSettings as Record<string, unknown>,
+      path,
+    );
+
+    if (value === undefined) {
+      return;
+    }
+
+    const existsInOriginalFile = settingExistsInScope(
+      settingKey,
+      loadedSettings.forScope(scope).settings,
+    );
+
+    const isDefaultValue = value === getDefaultValue(settingKey);
+
+    if (existsInOriginalFile || !isDefaultValue) {
+      // This is tricky because setValue only works on top-level keys.
+      // We need to set the whole parent object.
+      const [parentKey] = path;
+      if (parentKey) {
+        // Ensure value is a boolean for setPendingSettingValue
+        const booleanValue = typeof value === 'boolean' ? value : false;
+        const newParentValue = setPendingSettingValue(
+          settingKey,
+          booleanValue,
+          loadedSettings.forScope(scope).settings,
+        )[parentKey as keyof Settings];
+
+        loadedSettings.setValue(
+          scope,
+          parentKey as keyof Settings,
+          newParentValue,
+        );
+      }
+    }
+  });
+}
+
+/**
+ * Get the display value for a setting, showing current scope value with default change indicator
+ */
+export function getDisplayValue(
+  key: string,
+  settings: Settings,
+  _mergedSettings: Settings,
+  modifiedSettings: Set<string>,
+  pendingSettings?: Settings,
+): string {
+  // Prioritize pending changes if user has modified this setting
+  let value: boolean;
+  if (pendingSettings && settingExistsInScope(key, pendingSettings)) {
+    // Show the value from the pending (unsaved) edits when it exists
+    value = getSettingValue(key, pendingSettings, {});
+  } else if (settingExistsInScope(key, settings)) {
+    // Show the value defined at the current scope if present
+    value = getSettingValue(key, settings, {});
+  } else {
+    // Fall back to the schema default when the key is unset in this scope
+    const defaultValue = getDefaultValue(key);
+    value = typeof defaultValue === 'boolean' ? defaultValue : false;
+  }
+
+  const valueString = String(value);
+
+  // Check if value is different from default OR if it's in modified settings OR if there are pending changes
+  const defaultValue = getDefaultValue(key);
+  const isChangedFromDefault =
+    typeof defaultValue === 'boolean' ? value !== defaultValue : value === true;
+  const isInModifiedSettings = modifiedSettings.has(key);
+  const hasPendingChanges =
+    pendingSettings && settingExistsInScope(key, pendingSettings);
+
+  // Add * indicator when value differs from default, is in modified settings, or has pending changes
+  if (isChangedFromDefault || isInModifiedSettings || hasPendingChanges) {
+    return `${valueString}*`; // * indicates changed from default value
+  }
+
+  return valueString;
+}
+
+/**
+ * Check if a setting doesn't exist in current scope (should be greyed out)
+ */
+export function isDefaultValue(key: string, settings: Settings): boolean {
+  return !settingExistsInScope(key, settings);
+}
+
+/**
+ * Check if a setting value is inherited (not set at current scope)
+ */
+export function isValueInherited(
+  key: string,
+  settings: Settings,
+  _mergedSettings: Settings,
+): boolean {
+  return !settingExistsInScope(key, settings);
+}
+
+/**
+ * Get the effective value for display, considering inheritance
+ * Always returns a boolean value (never undefined)
+ */
+export function getEffectiveDisplayValue(
+  key: string,
+  settings: Settings,
+  mergedSettings: Settings,
+): boolean {
+  return getSettingValue(key, settings, mergedSettings);
+}

From 0157eae3d7467761451167ec350e8b49517414da Mon Sep 17 00:00:00 2001
From: Ali Al Jufairi <ali.redha.ali@gmail.com>
Date: Sun, 10 Aug 2025 11:56:53 +0900
Subject: [PATCH 081/107] fix(settings): enable default usage statistics
 collection (#5909)

---
 packages/cli/src/config/settingsSchema.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/packages/cli/src/config/settingsSchema.ts b/packages/cli/src/config/settingsSchema.ts
index dc2582ec..cd8c61fb 100644
--- a/packages/cli/src/config/settingsSchema.ts
+++ b/packages/cli/src/config/settingsSchema.ts
@@ -101,7 +101,7 @@ export const SETTINGS_SCHEMA = {
     label: 'Enable Usage Statistics',
     category: 'General',
     requiresRestart: true,
-    default: false,
+    default: true,
     description: 'Enable collection of usage statistics',
     showInDialog: true,
   },

From 0e44bbc85d912cabfa065cf48c65c018e3afb397 Mon Sep 17 00:00:00 2001
From: Dmitry Lyalin <dmitry.lyalin@lyalin.com>
Date: Sun, 10 Aug 2025 14:52:14 -0400
Subject: [PATCH 082/107] docs(readme): Overhaul for clarity and user
 experience (#5732)

Co-authored-by: gemini-code-assist[bot] <176961590+gemini-code-assist[bot]@users.noreply.github.com>
Co-authored-by: Srinath Padmanabhan <17151014+srithreepo@users.noreply.github.com>
---
 README.md | 411 +++++++++++++++++++++++++++++++-----------------------
 1 file changed, 234 insertions(+), 177 deletions(-)

diff --git a/README.md b/README.md
index b1c8f38c..697142d7 100644
--- a/README.md
+++ b/README.md
@@ -1,135 +1,182 @@
 # Gemini CLI
 
 [![Gemini CLI CI](https://github.com/google-gemini/gemini-cli/actions/workflows/ci.yml/badge.svg)](https://github.com/google-gemini/gemini-cli/actions/workflows/ci.yml)
+[![Version](https://img.shields.io/npm/v/@google/gemini-cli)](https://www.npmjs.com/package/@google/gemini-cli)
+[![License](https://img.shields.io/github/license/google-gemini/gemini-cli)](https://github.com/google-gemini/gemini-cli/blob/main/LICENSE)
 
 ![Gemini CLI Screenshot](./docs/assets/gemini-screenshot.png)
 
-This repository contains the Gemini CLI, a command-line AI workflow tool that connects to your
-tools, understands your code and accelerates your workflows.
+Gemini CLI is an open-source AI agent that brings the power of Gemini directly into your terminal. It provides lightweight access to Gemini, giving you the most direct path from your prompt to our model.
 
-With the Gemini CLI you can:
+## 🚀 Why Gemini CLI?
 
-- Query and edit large codebases in and beyond Gemini's 1M token context window.
-- Generate new apps from PDFs or sketches, using Gemini's multimodal capabilities.
-- Automate operational tasks, like querying pull requests or handling complex rebases.
-- Integrate with GitHub: Use the [Gemini CLI GitHub Action](https://github.com/google-github-actions/run-gemini-cli) for automated PR reviews, issue triage, and on-demand AI assistance directly in your repositories.
-- Use tools and MCP servers to connect new capabilities, including [media generation with Imagen,
-  Veo or Lyria](https://github.com/GoogleCloudPlatform/vertex-ai-creative-studio/tree/main/experiments/mcp-genmedia)
-- Ground your queries with the [Google Search](https://ai.google.dev/gemini-api/docs/grounding)
-  tool, built into Gemini.
+- **🎯 Free tier**: 60 requests/min and 1,000 requests/day with personal Google account
+- **🧠 Powerful Gemini 2.5 Pro**: Access to 1M token context window
+- **🔧 Built-in tools**: Google Search grounding, file operations, shell commands, web fetching
+- **🔌 Extensible**: MCP (Model Context Protocol) support for custom integrations
+- **💻 Terminal-first**: Designed for developers who live in the command line
+- **🛡️ Open source**: Apache 2.0 licensed
 
-## Quickstart
+## 📦 Installation
 
-You have two options to install Gemini CLI.
+### Quick Install
 
-### With Node
+#### Run instantly with npx
 
-1. **Prerequisites:** Ensure you have [Node.js version 20](https://nodejs.org/en/download) or higher installed.
-2. **Run the CLI:** Execute the following command in your terminal:
-
-   ```bash
-   npx https://github.com/google-gemini/gemini-cli
-   ```
-
-   Or install it with:
-
-   ```bash
-   npm install -g @google/gemini-cli
-   ```
-
-   Then, run the CLI from anywhere:
-
-   ```bash
-   gemini
-   ```
-
-### With Homebrew
-
-1. **Prerequisites:** Ensure you have [Homebrew](https://brew.sh/) installed.
-2. **Install the CLI:** Execute the following command in your terminal:
-
-   ```bash
-   brew install gemini-cli
-   ```
-
-   Then, run the CLI from anywhere:
-
-   ```bash
-   gemini
-   ```
-
-### Common Configuration steps
-
-3. **Pick a color theme**
-4. **Authenticate:** When prompted, sign in with your personal Google account. This will grant you up to 60 model requests per minute and 1,000 model requests per day using Gemini.
-
-You are now ready to use the Gemini CLI!
-
-### Use a Gemini API key:
-
-The Gemini API provides a free tier with [100 requests per day](https://ai.google.dev/gemini-api/docs/rate-limits#free-tier) using Gemini 2.5 Pro, control over which model you use, and access to higher rate limits (with a paid plan):
-
-1. Generate a key from [Google AI Studio](https://aistudio.google.com/apikey).
-2. Set it as an environment variable in your terminal. Replace `YOUR_API_KEY` with your generated key.
-
-   ```bash
-   export GEMINI_API_KEY="YOUR_API_KEY"
-   ```
-
-3. (Optionally) Upgrade your Gemini API project to a paid plan on the API key page (will automatically unlock [Tier 1 rate limits](https://ai.google.dev/gemini-api/docs/rate-limits#tier-1))
-
-### Use a Vertex AI API key:
-
-The Vertex AI API provides a [free tier](https://cloud.google.com/vertex-ai/generative-ai/docs/start/express-mode/overview) using express mode for Gemini 2.5 Pro, control over which model you use, and access to higher rate limits with a billing account:
-
-1. Generate a key from [Google Cloud](https://cloud.google.com/vertex-ai/generative-ai/docs/start/api-keys).
-2. Set it as an environment variable in your terminal. Replace `YOUR_API_KEY` with your generated key and set GOOGLE_GENAI_USE_VERTEXAI to true
-
-   ```bash
-   export GOOGLE_API_KEY="YOUR_API_KEY"
-   export GOOGLE_GENAI_USE_VERTEXAI=true
-   ```
-
-3. (Optionally) Add a billing account on your project to get access to [higher usage limits](https://cloud.google.com/vertex-ai/generative-ai/docs/quotas)
-
-For other authentication methods, including Google Workspace accounts, see the [authentication](./docs/cli/authentication.md) guide.
-
-## Examples
-
-Once the CLI is running, you can start interacting with Gemini from your shell.
-
-You can start a project from a new directory:
-
-```sh
-cd new-project/
-gemini
-> Write me a Gemini Discord bot that answers questions using a FAQ.md file I will provide
+```bash
+# Using npx (no installation required)
+npx https://github.com/google-gemini/gemini-cli
 ```
 
-Or work with an existing project:
+#### Install globally with npm
 
-```sh
+```bash
+npm install -g @google/gemini-cli
+```
+
+#### Install globally with Homebrew (macOS/Linux)
+
+```bash
+brew install gemini-cli
+```
+
+#### System Requirements
+
+- Node.js version 20 or higher
+- macOS, Linux, or Windows
+
+## 📋 Key Features
+
+With Gemini CLI you can:
+
+- **Code Understanding & Generation**
+  - Query and edit large codebases
+  - Generate new apps from PDFs, images, or sketches using multimodal capabilities
+  - Debug issues and troubleshoot with natural language
+- **Automation & Integration**
+  - Automate operational tasks like querying pull requests or handling complex rebases
+  - Use MCP servers to connect new capabilities, including [media generation with Imagen, Veo or Lyria](https://github.com/GoogleCloudPlatform/vertex-ai-creative-studio/tree/main/experiments/mcp-genmedia)
+  - Run non-interactively in scripts for workflow automation
+- **Advanced Capabilities**
+  - Ground your queries with built-in [Google Search](https://ai.google.dev/gemini-api/docs/grounding) for real-time information
+  - Conversation checkpointing to save and resume complex sessions
+  - Custom context files (GEMINI.md) to tailor behavior for your projects
+
+- **🔗 GitHub Integration**
+  - Use the Gemini CLI GitHub Action for automated PR reviews
+  - Automated issue triage and on-demand AI assistance directly in your repositories
+  - Seamless integration with your GitHub workflows
+
+## 🔐 Authentication Options
+
+Choose the authentication method that best fits your needs:
+
+### Option 1: OAuth login (Using your Google Account)
+
+**✨ Best for:** Individual developers as well as anyone who has a Gemini Code Assist License. (see [quota limits and terms of service](https://cloud.google.com/gemini/docs/quotas) for details)
+
+**Benefits:**
+
+- **Free tier**: 60 requests/min and 1,000 requests/day
+- **Gemini 2.5 Pro** with 1M token context window
+- **No API key management** - just sign in with your Google account
+- **Automatic updates** to latest models
+
+#### Start Gemini CLI, then choose OAuth and follow the browser authentication flow when prompted
+
+```bash
+gemini
+```
+
+#### If you are using a paid Code Assist License from your organization, remember to set the Google Cloud Project
+
+```bash
+# Set your Google Cloud Project
+export GOOGLE_CLOUD_PROJECT="YOUR_PROJECT_NAME"
+gemini
+```
+
+### Option 2: Gemini API Key
+
+**✨ Best for:** Developers who need specific model control or paid tier access
+
+**Benefits:**
+
+- **Free tier**: 100 requests/day with Gemini 2.5 Pro
+- **Model selection**: Choose specific Gemini models
+- **Usage-based billing**: Upgrade for higher limits when needed
+
+```bash
+# Get your key from https://aistudio.google.com/apikey
+export GEMINI_API_KEY="YOUR_API_KEY"
+gemini
+```
+
+### Option 3: Vertex AI
+
+**✨ Best for:** Enterprise teams and production workloads
+
+**Benefits:**
+
+- **Enterprise features**: Advanced security and compliance
+- **Scalable**: Higher rate limits with billing account
+- **Integration**: Works with existing Google Cloud infrastructure
+
+```bash
+# Get your key from Google Cloud Console
+export GOOGLE_API_KEY="YOUR_API_KEY"
+export GOOGLE_GENAI_USE_VERTEXAI=true
+gemini
+```
+
+For Google Workspace accounts and other authentication methods, see the [authentication guide](./docs/cli/authentication.md).
+
+## 🚀 Getting Started
+
+### Basic Usage
+
+#### Start in current directory
+
+```bash
+gemini
+```
+
+#### Include multiple directories
+
+```bash
+gemini --include-directories ../lib,../docs
+```
+
+#### Use specific model
+
+```bash
+gemini -m gemini-2.5-flash
+```
+
+#### Non-interactive mode for scripts
+
+```bash
+gemini -p "Explain the architecture of this codebase"
+```
+
+### Quick Examples
+
+#### Start a new project
+
+````bash
+cd new-project/
+gemini
+> Write me a Discord bot that answers questions using a FAQ.md file I will provide
+
+#### Analyze existing code
+```bash
 git clone https://github.com/google-gemini/gemini-cli
 cd gemini-cli
 gemini
 > Give me a summary of all of the changes that went in yesterday
-```
+````
 
-### Next steps
-
-- Learn how to [contribute to or build from the source](./CONTRIBUTING.md).
-- Explore the available **[CLI Commands](./docs/cli/commands.md)**.
-- If you encounter any issues, review the **[troubleshooting guide](./docs/troubleshooting.md)**.
-- For more comprehensive documentation, see the [full documentation](./docs/index.md).
-- Take a look at some [popular tasks](#popular-tasks) for more inspiration.
-- Check out our **[Official Roadmap](./ROADMAP.md)**
-
-### Troubleshooting
-
-Head over to the [troubleshooting guide](docs/troubleshooting.md) if you're
-having issues.
-
-## GitHub Integration
+## 🔗 GitHub Integration
 
 Integrate Gemini CLI directly into your GitHub workflows with the [**Gemini CLI GitHub Action**](https://github.com/google-github-actions/run-gemini-cli). Key features include:
 
@@ -138,88 +185,98 @@ Integrate Gemini CLI directly into your GitHub workflows with the [**Gemini CLI
 - **On-demand Collaboration**: Mention `@gemini-cli` in issues and pull requests for assistance and task delegation.
 - **Custom Workflows**: Set up your own scheduled tasks and event-driven automations.
 
-## Popular tasks
+## 📚 Documentation
 
-### Explore a new codebase
+### Getting Started
 
-Start by `cd`ing into an existing or newly-cloned repository and running `gemini`.
+- [**Quickstart Guide**](./docs/cli/index.md) - Get up and running quickly
+- [**Authentication Setup**](./docs/cli/authentication.md) - Detailed auth configuration
+- [**Configuration Guide**](./docs/cli/configuration.md) - Settings and customization
+- [**Keyboard Shortcuts**](./docs/keyboard-shortcuts.md) - Productivity tips
+
+### Core Features
+
+- [**Commands Reference**](./docs/cli/commands.md) - All slash commands (`/help`, `/chat`, `/mcp`, etc.)
+- [**Checkpointing**](./docs/checkpointing.md) - Save and resume conversations
+- [**Memory Management**](./docs/tools/memory.md) - Using GEMINI.md context files
+- [**Token Caching**](./docs/cli/token-caching.md) - Optimize token usage
+
+### Tools & Extensions
+
+- [**Built-in Tools Overview**](./docs/tools/index.md)
+  - [File System Operations](./docs/tools/file-system.md)
+  - [Shell Commands](./docs/tools/shell.md)
+  - [Web Fetch & Search](./docs/tools/web-fetch.md)
+  - [Multi-file Operations](./docs/tools/multi-file.md)
+- [**MCP Server Integration**](./docs/tools/mcp-server.md) - Extend with custom tools
+- [**Custom Extensions**](./docs/extension.md) - Build your own commands
+
+### Advanced Topics
+
+- [**Architecture Overview**](./docs/architecture.md) - How Gemini CLI works
+- [**IDE Integration**](./docs/extension.md) - VS Code companion
+- [**Sandboxing & Security**](./docs/sandbox.md) - Safe execution environments
+- [**Enterprise Deployment**](./docs/deployment.md) - Docker, system-wide config
+- [**Telemetry & Monitoring**](./docs/telemetry.md) - Usage tracking
+- [**Tools API Development**](./docs/core/tools-api.md) - Create custom tools
+
+### Configuration & Customization
+
+- [**Settings Reference**](./docs/cli/configuration.md) - All configuration options
+- [**Theme Customization**](./docs/cli/themes.md) - Visual customization
+- [**.gemini Directory**](./docs/gemini-ignore.md) - Project-specific settings
+- [**Environment Variables**](./docs/cli/configuration.md#environment-variables)
+
+### Troubleshooting & Support
+
+- [**Troubleshooting Guide**](./docs/troubleshooting.md) - Common issues and solutions
+- [**FAQ**](./docs/troubleshooting.md#frequently-asked-questions) - Quick answers
+- Use `/bug` command to report issues directly from the CLI
+
+### Using MCP Servers
+
+Configure MCP servers in `~/.gemini/settings.json` to extend Gemini CLI with custom tools:
 
 ```text
-> Describe the main pieces of this system's architecture.
+> @github List my open pull requests
+> @slack Send a summary of today's commits to #dev channel
+> @database Run a query to find inactive users
 ```
 
-```text
-> What security mechanisms are in place?
-```
+See the [MCP Server Integration guide](./docs/tools/mcp-server.md) for setup instructions.
 
-```text
-> Provide a step-by-step dev onboarding doc for developers new to the codebase.
-```
+## 🤝 Contributing
 
-```text
-> Summarize this codebase and highlight the most interesting patterns or techniques I could learn from.
-```
+We welcome contributions! Gemini CLI is fully open source (Apache 2.0), and we encourage the community to:
 
-```text
-> Identify potential areas for improvement or refactoring in this codebase, highlighting parts that appear fragile, complex, or hard to maintain.
-```
+- Report bugs and suggest features
+- Improve documentation
+- Submit code improvements
+- Share your MCP servers and extensions
 
-```text
-> Which parts of this codebase might be challenging to scale or debug?
-```
+See our [Contributing Guide](./CONTRIBUTING.md) for development setup, coding standards, and how to submit pull requests.
 
-```text
-> Generate a README section for the [module name] module explaining what it does and how to use it.
-```
+Check our [Official Roadmap](https://github.com/orgs/google-gemini/projects/11/) for planned features and priorities.
 
-```text
-> What kind of error handling and logging strategies does the project use?
-```
+## 📖 Resources
 
-```text
-> Which tools, libraries, and dependencies are used in this project?
-```
-
-### Work with your existing code
-
-```text
-> Implement a first draft for GitHub issue #123.
-```
-
-```text
-> Help me migrate this codebase to the latest version of Java. Start with a plan.
-```
-
-### Automate your workflows
-
-Use MCP servers to integrate your local system tools with your enterprise collaboration suite.
-
-```text
-> Make me a slide deck showing the git history from the last 7 days, grouped by feature and team member.
-```
-
-```text
-> Make a full-screen web app for a wall display to show our most interacted-with GitHub issues.
-```
-
-### Interact with your system
-
-```text
-> Convert all the images in this directory to png, and rename them to use dates from the exif data.
-```
-
-```text
-> Organize my PDF invoices by month of expenditure.
-```
+- **[Official Roadmap](./ROADMAP.md)** - See what's coming next
+- **[NPM Package](https://www.npmjs.com/package/@google/gemini-cli)** - Package registry
+- **[GitHub Issues](https://github.com/google-gemini/gemini-cli/issues)** - Report bugs or request features
+- **[Security Advisories](https://github.com/google-gemini/gemini-cli/security/advisories)** - Security updates
 
 ### Uninstall
 
-Head over to the [Uninstall](docs/Uninstall.md) guide for uninstallation instructions.
+See the [Uninstall Guide](docs/Uninstall.md) for removal instructions.
 
-## Terms of Service and Privacy Notice
+## 📄 Legal
 
-For details on the terms of service and privacy notice applicable to your use of Gemini CLI, see the [Terms of Service and Privacy Notice](./docs/tos-privacy.md).
+- **License**: [Apache License 2.0](LICENSE)
+- **Terms of Service**: [Terms & Privacy](./docs/tos-privacy.md)
+- **Security**: [Security Policy](SECURITY.md)
 
-## Security Disclosures
+---
 
-Please see our [security disclosure process](SECURITY.md). All [security advisories](https://github.com/google-gemini/gemini-cli/security/advisories) are managed on Github.
+<p align="center">
+  Built with ❤️ by Google and the open source community
+</p>

From 2865a527787a741e478f542c57b4c4b0049a5adf Mon Sep 17 00:00:00 2001
From: Gal Zahavi <38544478+galz10@users.noreply.github.com>
Date: Sun, 10 Aug 2025 12:06:35 -0700
Subject: [PATCH 083/107] docs(config): Add showLineNumbers option to
 documentation (#5947)

---
 docs/cli/configuration.md | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/docs/cli/configuration.md b/docs/cli/configuration.md
index 9fc74adb..6ebcd630 100644
--- a/docs/cli/configuration.md
+++ b/docs/cli/configuration.md
@@ -280,6 +280,14 @@ In addition to a project settings file, a project's `.gemini` directory can cont
     }
     ```
 
+- **`showLineNumbers`** (boolean):
+  - **Description:** Controls whether line numbers are displayed in code blocks in the CLI output.
+  - **Default:** `true`
+  - **Example:**
+    ```json
+    "showLineNumbers": false
+    ```
+
 ### Example `settings.json`:
 
 ```json

From 2548facc79f8b52a85d00c562d05d0933616ea95 Mon Sep 17 00:00:00 2001
From: Lee James <40045512+leehagoodjames@users.noreply.github.com>
Date: Mon, 11 Aug 2025 11:11:20 -0400
Subject: [PATCH 084/107] feat: add "surface" to all logs (#5862)

---
 .../clearcut-logger/clearcut-logger.ts        | 30 ++++++++++++-------
 1 file changed, 19 insertions(+), 11 deletions(-)

diff --git a/packages/core/src/telemetry/clearcut-logger/clearcut-logger.ts b/packages/core/src/telemetry/clearcut-logger/clearcut-logger.ts
index 09ae6741..1e67d1cf 100644
--- a/packages/core/src/telemetry/clearcut-logger/clearcut-logger.ts
+++ b/packages/core/src/telemetry/clearcut-logger/clearcut-logger.ts
@@ -150,13 +150,27 @@ export class ClearcutLogger {
     }
   }
 
+  addDefaultFields(data: EventValue[]): void {
+    const totalAccounts = getLifetimeGoogleAccounts();
+    const surface = determineSurface();
+    const defaultLogMetadata = [
+      {
+        gemini_cli_key: EventMetadataKey.GEMINI_CLI_GOOGLE_ACCOUNTS_COUNT,
+        value: totalAccounts.toString(),
+      },
+      {
+        gemini_cli_key: EventMetadataKey.GEMINI_CLI_SURFACE,
+        value: surface,
+      },
+    ];
+    data.push(...defaultLogMetadata);
+  }
+
   createLogEvent(name: string, data: EventValue[]): LogEvent {
     const email = getCachedGoogleAccount();
-    const totalAccounts = getLifetimeGoogleAccounts();
-    data.push({
-      gemini_cli_key: EventMetadataKey.GEMINI_CLI_GOOGLE_ACCOUNTS_COUNT,
-      value: totalAccounts.toString(),
-    });
+
+    // Add default fields that should exist for all logs
+    this.addDefaultFields(data);
 
     const logEvent: LogEvent = {
       console_type: 'GEMINI_CLI',
@@ -340,8 +354,6 @@ export class ClearcutLogger {
   }
 
   logStartSessionEvent(event: StartSessionEvent): void {
-    const surface = determineSurface();
-
     const data: EventValue[] = [
       {
         gemini_cli_key: EventMetadataKey.GEMINI_CLI_START_SESSION_MODEL,
@@ -407,10 +419,6 @@ export class ClearcutLogger {
           EventMetadataKey.GEMINI_CLI_START_SESSION_TELEMETRY_LOG_USER_PROMPTS_ENABLED,
         value: event.telemetry_log_user_prompts_enabled.toString(),
       },
-      {
-        gemini_cli_key: EventMetadataKey.GEMINI_CLI_SURFACE,
-        value: surface,
-      },
     ];
 
     // Flush start event immediately

From 8dd6f04199f7d14c27595d960d2a84d4e189342b Mon Sep 17 00:00:00 2001
From: christine betts <chrstn@uw.edu>
Date: Mon, 11 Aug 2025 16:13:45 +0000
Subject: [PATCH 085/107] Show IDE diff options in both panes (#5986)

---
 .../vscode-ide-companion/src/diff-manager.ts     | 16 ++++++++++++----
 1 file changed, 12 insertions(+), 4 deletions(-)

diff --git a/packages/vscode-ide-companion/src/diff-manager.ts b/packages/vscode-ide-companion/src/diff-manager.ts
index 9c7afc1d..abbc6eec 100644
--- a/packages/vscode-ide-companion/src/diff-manager.ts
+++ b/packages/vscode-ide-companion/src/diff-manager.ts
@@ -214,10 +214,18 @@ export class DiffManager {
   }
 
   private async onActiveEditorChange(editor: vscode.TextEditor | undefined) {
-    const isVisible =
-      !!editor &&
-      editor.document.uri.scheme === DIFF_SCHEME &&
-      this.diffDocuments.has(editor.document.uri.toString());
+    let isVisible = false;
+    if (editor) {
+      isVisible = this.diffDocuments.has(editor.document.uri.toString());
+      if (!isVisible) {
+        for (const document of this.diffDocuments.values()) {
+          if (document.originalFilePath === editor.document.uri.fsPath) {
+            isVisible = true;
+            break;
+          }
+        }
+      }
+    }
     await vscode.commands.executeCommand(
       'setContext',
       'gemini.diff.isVisible',

From b0b12af2ce843e560133ddc64511917264945072 Mon Sep 17 00:00:00 2001
From: Shreya Keshive <skeshive@gmail.com>
Date: Mon, 11 Aug 2025 12:27:45 -0400
Subject: [PATCH 086/107] Additional IDE integration polishes (#5985)

---
 packages/cli/src/ui/commands/ideCommand.ts |  8 ++++++--
 packages/core/src/ide/ide-client.ts        | 15 ++++++++++-----
 packages/vscode-ide-companion/README.md    |  4 ++--
 3 files changed, 18 insertions(+), 9 deletions(-)

diff --git a/packages/cli/src/ui/commands/ideCommand.ts b/packages/cli/src/ui/commands/ideCommand.ts
index 95aa5711..f53047ef 100644
--- a/packages/cli/src/ui/commands/ideCommand.ts
+++ b/packages/cli/src/ui/commands/ideCommand.ts
@@ -72,7 +72,10 @@ function formatFileList(openFiles: File[]): string {
     })
     .join('\n');
 
-  return `\n\nOpen files:\n${fileList}`;
+  const infoMessage = `
+(Note: The file list is limited to a number of recently accessed files within your workspace and only includes local files on disk)`;
+
+  return `\n\nOpen files:\n${fileList}\n${infoMessage}`;
 }
 
 async function getIdeStatusMessageWithFiles(ideClient: IdeClient): Promise<{
@@ -128,7 +131,8 @@ export const ideCommand = (config: Config | null): SlashCommand | null => {
           messageType: 'error',
           content: `IDE integration is not supported in your current environment. To use this feature, run Gemini CLI in one of these supported IDEs: ${Object.values(
             DetectedIde,
-          ).map((ide) => getIdeDisplayName(ide))}
+          )
+            .map((ide) => getIdeDisplayName(ide))
             .join(', ')}`,
         }) as const,
     };
diff --git a/packages/core/src/ide/ide-client.ts b/packages/core/src/ide/ide-client.ts
index 69329bee..5842a8a8 100644
--- a/packages/core/src/ide/ide-client.ts
+++ b/packages/core/src/ide/ide-client.ts
@@ -215,13 +215,18 @@ export class IdeClient {
     // disconnected, so that the first detail message is preserved.
     if (!isAlreadyDisconnected) {
       this.state = { status, details };
-      if (logToConsole) {
-        logger.error(details);
+      if (details) {
+        if (logToConsole) {
+          logger.error(details);
+        } else {
+          // We only want to log disconnect messages to debug
+          // if they are not already being logged to the console.
+          logger.debug(details);
+        }
       }
     }
 
     if (status === IDEConnectionStatus.Disconnected) {
-      logger.debug(details);
       ideContext.clearIdeContext();
     }
   }
@@ -260,7 +265,7 @@ export class IdeClient {
     if (!port) {
       this.setState(
         IDEConnectionStatus.Disconnected,
-        `Failed to connect to IDE companion extension for ${this.currentIdeDisplayName}. Please ensure the extension is running and try refreshing your terminal. To install the extension, run /ide install.`,
+        `Failed to connect to IDE companion extension for ${this.currentIdeDisplayName}. Please ensure the extension is running and try restarting your terminal. To install the extension, run /ide install.`,
         true,
       );
       return undefined;
@@ -339,7 +344,7 @@ export class IdeClient {
     } catch (_error) {
       this.setState(
         IDEConnectionStatus.Disconnected,
-        `Failed to connect to IDE companion extension for ${this.currentIdeDisplayName}. Please ensure the extension is running and try refreshing your terminal. To install the extension, run /ide install.`,
+        `Failed to connect to IDE companion extension for ${this.currentIdeDisplayName}. Please ensure the extension is running and try restarting your terminal. To install the extension, run /ide install.`,
         true,
       );
       if (transport) {
diff --git a/packages/vscode-ide-companion/README.md b/packages/vscode-ide-companion/README.md
index 49de94a1..ebc751e6 100644
--- a/packages/vscode-ide-companion/README.md
+++ b/packages/vscode-ide-companion/README.md
@@ -1,6 +1,6 @@
 # Gemini CLI Companion
 
-The Gemini CLI Companion extension seamlessly integrates [Gemini CLI](https://github.com/google-gemini/gemini-cli) into your VS Code environment. This integration enables Gemini CLI to access active information like your open files.
+The Gemini CLI Companion extension seamlessly integrates [Gemini CLI](https://github.com/google-gemini/gemini-cli) into your IDE.
 
 # Features
 
@@ -17,7 +17,7 @@ The Gemini CLI Companion extension seamlessly integrates [Gemini CLI](https://gi
 To use this extension, you'll need:
 
 - VS Code version 1.99.0 or newer
-- Gemini CLI (installed separately) running within the VS Code integrated terminal
+- Gemini CLI (installed separately) running within the integrated terminal
 
 # Terms of Service and Privacy Notice
 

From aa5c80dec487ab02513c170ddd59285d94c71f29 Mon Sep 17 00:00:00 2001
From: cornmander <shikhman@google.com>
Date: Mon, 11 Aug 2025 12:40:30 -0400
Subject: [PATCH 087/107] feat(core): add host validation to
 GoogleCredentialProvider (#5962)

Co-authored-by: Brian Ray <62354532+emeryray2002@users.noreply.github.com>
---
 .../core/src/mcp/google-auth-provider.test.ts | 64 ++++++++++++++++---
 packages/core/src/mcp/google-auth-provider.ts | 16 +++++
 packages/core/src/tools/mcp-client.test.ts    |  6 +-
 3 files changed, 73 insertions(+), 13 deletions(-)

diff --git a/packages/core/src/mcp/google-auth-provider.test.ts b/packages/core/src/mcp/google-auth-provider.test.ts
index f481b9e2..65daa74f 100644
--- a/packages/core/src/mcp/google-auth-provider.test.ts
+++ b/packages/core/src/mcp/google-auth-provider.test.ts
@@ -12,34 +12,78 @@ import { MCPServerConfig } from '../config/config.js';
 vi.mock('google-auth-library');
 
 describe('GoogleCredentialProvider', () => {
+  const validConfig = {
+    url: 'https://test.googleapis.com',
+    oauth: {
+      scopes: ['scope1', 'scope2'],
+    },
+  } as MCPServerConfig;
+
   it('should throw an error if no scopes are provided', () => {
-    expect(() => new GoogleCredentialProvider()).toThrow(
+    const config = {
+      url: 'https://test.googleapis.com',
+    } as MCPServerConfig;
+    expect(() => new GoogleCredentialProvider(config)).toThrow(
       'Scopes must be provided in the oauth config for Google Credentials provider',
     );
   });
 
   it('should use scopes from the config if provided', () => {
+    new GoogleCredentialProvider(validConfig);
+    expect(GoogleAuth).toHaveBeenCalledWith({
+      scopes: ['scope1', 'scope2'],
+    });
+  });
+
+  it('should throw an error for a non-allowlisted host', () => {
     const config = {
+      url: 'https://example.com',
+      oauth: {
+        scopes: ['scope1', 'scope2'],
+      },
+    } as MCPServerConfig;
+    expect(() => new GoogleCredentialProvider(config)).toThrow(
+      'Host "example.com" is not an allowed host for Google Credential provider.',
+    );
+  });
+
+  it('should allow luci.app', () => {
+    const config = {
+      url: 'https://luci.app',
       oauth: {
         scopes: ['scope1', 'scope2'],
       },
     } as MCPServerConfig;
     new GoogleCredentialProvider(config);
-    expect(GoogleAuth).toHaveBeenCalledWith({
-      scopes: ['scope1', 'scope2'],
-    });
+  });
+
+  it('should allow sub.luci.app', () => {
+    const config = {
+      url: 'https://sub.luci.app',
+      oauth: {
+        scopes: ['scope1', 'scope2'],
+      },
+    } as MCPServerConfig;
+    new GoogleCredentialProvider(config);
+  });
+
+  it('should not allow googleapis.com without a subdomain', () => {
+    const config = {
+      url: 'https://googleapis.com',
+      oauth: {
+        scopes: ['scope1', 'scope2'],
+      },
+    } as MCPServerConfig;
+    expect(() => new GoogleCredentialProvider(config)).toThrow(
+      'Host "googleapis.com" is not an allowed host for Google Credential provider.',
+    );
   });
 
   describe('with provider instance', () => {
     let provider: GoogleCredentialProvider;
 
     beforeEach(() => {
-      const config = {
-        oauth: {
-          scopes: ['scope1', 'scope2'],
-        },
-      } as MCPServerConfig;
-      provider = new GoogleCredentialProvider(config);
+      provider = new GoogleCredentialProvider(validConfig);
       vi.clearAllMocks();
     });
 
diff --git a/packages/core/src/mcp/google-auth-provider.ts b/packages/core/src/mcp/google-auth-provider.ts
index 88cd086b..2b52f734 100644
--- a/packages/core/src/mcp/google-auth-provider.ts
+++ b/packages/core/src/mcp/google-auth-provider.ts
@@ -14,6 +14,8 @@ import {
 import { GoogleAuth } from 'google-auth-library';
 import { MCPServerConfig } from '../config/config.js';
 
+const ALLOWED_HOSTS = [/^.+\.googleapis\.com$/, /^(.*\.)?luci\.app$/];
+
 export class GoogleCredentialProvider implements OAuthClientProvider {
   private readonly auth: GoogleAuth;
 
@@ -29,6 +31,20 @@ export class GoogleCredentialProvider implements OAuthClientProvider {
   private _clientInformation?: OAuthClientInformationFull;
 
   constructor(private readonly config?: MCPServerConfig) {
+    const url = this.config?.url || this.config?.httpUrl;
+    if (!url) {
+      throw new Error(
+        'URL must be provided in the config for Google Credentials provider',
+      );
+    }
+
+    const hostname = new URL(url).hostname;
+    if (!ALLOWED_HOSTS.some((pattern) => pattern.test(hostname))) {
+      throw new Error(
+        `Host "${hostname}" is not an allowed host for Google Credential provider.`,
+      );
+    }
+
     const scopes = this.config?.oauth?.scopes;
     if (!scopes || scopes.length === 0) {
       throw new Error(
diff --git a/packages/core/src/tools/mcp-client.test.ts b/packages/core/src/tools/mcp-client.test.ts
index d37c6eae..e54c3e0f 100644
--- a/packages/core/src/tools/mcp-client.test.ts
+++ b/packages/core/src/tools/mcp-client.test.ts
@@ -568,7 +568,7 @@ describe('mcp-client', () => {
         const transport = await createTransport(
           'test-server',
           {
-            httpUrl: 'http://test-server',
+            httpUrl: 'http://test.googleapis.com',
             authProviderType: AuthProviderType.GOOGLE_CREDENTIALS,
             oauth: {
               scopes: ['scope1'],
@@ -587,7 +587,7 @@ describe('mcp-client', () => {
         const transport = await createTransport(
           'test-server',
           {
-            url: 'http://test-server',
+            url: 'http://test.googleapis.com',
             authProviderType: AuthProviderType.GOOGLE_CREDENTIALS,
             oauth: {
               scopes: ['scope1'],
@@ -615,7 +615,7 @@ describe('mcp-client', () => {
             false,
           ),
         ).rejects.toThrow(
-          'No URL configured for Google Credentials MCP server',
+          'URL must be provided in the config for Google Credentials provider',
         );
       });
     });

From 2269f8a1a839f2dbdb45f5abda7981fce50f654c Mon Sep 17 00:00:00 2001
From: Jacob Richman <jacob314@gmail.com>
Date: Mon, 11 Aug 2025 10:15:44 -0700
Subject: [PATCH 088/107] Modify content generated describing the ide context
 to only include deltas after the initial update (#5880)

---
 packages/core/src/core/client.test.ts | 361 +++++++++++++++++++++++---
 packages/core/src/core/client.ts      | 226 +++++++++++++---
 2 files changed, 509 insertions(+), 78 deletions(-)

diff --git a/packages/core/src/core/client.test.ts b/packages/core/src/core/client.test.ts
index ff901a8b..2e8d086f 100644
--- a/packages/core/src/core/client.test.ts
+++ b/packages/core/src/core/client.test.ts
@@ -201,6 +201,7 @@ describe('Gemini Client (client.ts)', () => {
       getUsageStatisticsEnabled: vi.fn().mockReturnValue(true),
       getIdeModeFeature: vi.fn().mockReturnValue(false),
       getIdeMode: vi.fn().mockReturnValue(true),
+      getDebugMode: vi.fn().mockReturnValue(false),
       getWorkspaceContext: vi.fn().mockReturnValue({
         getDirectories: vi.fn().mockReturnValue(['/test/dir']),
       }),
@@ -449,8 +450,7 @@ describe('Gemini Client (client.ts)', () => {
       const mockChat = {
         addHistory: vi.fn(),
       };
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      client['chat'] = mockChat as any;
+      client['chat'] = mockChat as unknown as GeminiChat;
 
       const newContent = {
         role: 'user',
@@ -667,7 +667,7 @@ describe('Gemini Client (client.ts)', () => {
   });
 
   describe('sendMessageStream', () => {
-    it('should include IDE context when ideModeFeature is enabled', async () => {
+    it('should include editor context when ideModeFeature is enabled', async () => {
       // Arrange
       vi.mocked(ideContext.getIdeContext).mockReturnValue({
         workspaceState: {
@@ -725,21 +725,30 @@ describe('Gemini Client (client.ts)', () => {
       // Assert
       expect(ideContext.getIdeContext).toHaveBeenCalled();
       const expectedContext = `
-This is the file that the user is looking at:
-- Path: /path/to/active/file.ts
-This is the cursor position in the file:
-- Cursor Position: Line 5, Character 10
-This is the selected text in the file:
-- hello
-Here are some other files the user has open, with the most recent at the top:
-- /path/to/recent/file1.ts
-- /path/to/recent/file2.ts
+Here is the user's editor context as a JSON object. This is for your information only.
+\`\`\`json
+${JSON.stringify(
+  {
+    activeFile: {
+      path: '/path/to/active/file.ts',
+      cursor: {
+        line: 5,
+        character: 10,
+      },
+      selectedText: 'hello',
+    },
+    otherOpenFiles: ['/path/to/recent/file1.ts', '/path/to/recent/file2.ts'],
+  },
+  null,
+  2,
+)}
+\`\`\`
       `.trim();
-      const expectedRequest = [{ text: expectedContext }, ...initialRequest];
-      expect(mockTurnRunFn).toHaveBeenCalledWith(
-        expectedRequest,
-        expect.any(Object),
-      );
+      const expectedRequest = [{ text: expectedContext }];
+      expect(mockChat.addHistory).toHaveBeenCalledWith({
+        role: 'user',
+        parts: expectedRequest,
+      });
     });
 
     it('should not add context if ideModeFeature is enabled but no open files', async () => {
@@ -839,18 +848,29 @@ Here are some other files the user has open, with the most recent at the top:
       // Assert
       expect(ideContext.getIdeContext).toHaveBeenCalled();
       const expectedContext = `
-This is the file that the user is looking at:
-- Path: /path/to/active/file.ts
-This is the cursor position in the file:
-- Cursor Position: Line 5, Character 10
-This is the selected text in the file:
-- hello
+Here is the user's editor context as a JSON object. This is for your information only.
+\`\`\`json
+${JSON.stringify(
+  {
+    activeFile: {
+      path: '/path/to/active/file.ts',
+      cursor: {
+        line: 5,
+        character: 10,
+      },
+      selectedText: 'hello',
+    },
+  },
+  null,
+  2,
+)}
+\`\`\`
       `.trim();
-      const expectedRequest = [{ text: expectedContext }, ...initialRequest];
-      expect(mockTurnRunFn).toHaveBeenCalledWith(
-        expectedRequest,
-        expect.any(Object),
-      );
+      const expectedRequest = [{ text: expectedContext }];
+      expect(mockChat.addHistory).toHaveBeenCalledWith({
+        role: 'user',
+        parts: expectedRequest,
+      });
     });
 
     it('should add context if ideModeFeature is enabled and there are open files but no active file', async () => {
@@ -904,15 +924,22 @@ This is the selected text in the file:
       // Assert
       expect(ideContext.getIdeContext).toHaveBeenCalled();
       const expectedContext = `
-Here are some files the user has open, with the most recent at the top:
-- /path/to/recent/file1.ts
-- /path/to/recent/file2.ts
+Here is the user's editor context as a JSON object. This is for your information only.
+\`\`\`json
+${JSON.stringify(
+  {
+    otherOpenFiles: ['/path/to/recent/file1.ts', '/path/to/recent/file2.ts'],
+  },
+  null,
+  2,
+)}
+\`\`\`
       `.trim();
-      const expectedRequest = [{ text: expectedContext }, ...initialRequest];
-      expect(mockTurnRunFn).toHaveBeenCalledWith(
-        expectedRequest,
-        expect.any(Object),
-      );
+      const expectedRequest = [{ text: expectedContext }];
+      expect(mockChat.addHistory).toHaveBeenCalledWith({
+        role: 'user',
+        parts: expectedRequest,
+      });
     });
 
     it('should return the turn instance after the stream is complete', async () => {
@@ -1190,6 +1217,268 @@ Here are some files the user has open, with the most recent at the top:
           `${eventCount} events generated (properly bounded by MAX_TURNS)`,
       );
     });
+
+    describe('Editor context delta', () => {
+      const mockStream = (async function* () {
+        yield { type: 'content', value: 'Hello' };
+      })();
+
+      beforeEach(() => {
+        client['forceFullIdeContext'] = false; // Reset before each delta test
+        vi.spyOn(client, 'tryCompressChat').mockResolvedValue(null);
+        vi.spyOn(client['config'], 'getIdeModeFeature').mockReturnValue(true);
+        mockTurnRunFn.mockReturnValue(mockStream);
+
+        const mockChat: Partial<GeminiChat> = {
+          addHistory: vi.fn(),
+          setHistory: vi.fn(),
+          sendMessage: vi.fn().mockResolvedValue({ text: 'summary' }),
+          // Assume history is not empty for delta checks
+          getHistory: vi
+            .fn()
+            .mockReturnValue([
+              { role: 'user', parts: [{ text: 'previous message' }] },
+            ]),
+        };
+        client['chat'] = mockChat as GeminiChat;
+
+        const mockGenerator: Partial<ContentGenerator> = {
+          countTokens: vi.fn().mockResolvedValue({ totalTokens: 0 }),
+          generateContent: mockGenerateContentFn,
+        };
+        client['contentGenerator'] = mockGenerator as ContentGenerator;
+      });
+
+      const testCases = [
+        {
+          description: 'sends delta when active file changes',
+          previousActiveFile: {
+            path: '/path/to/old/file.ts',
+            cursor: { line: 5, character: 10 },
+            selectedText: 'hello',
+          },
+          currentActiveFile: {
+            path: '/path/to/active/file.ts',
+            cursor: { line: 5, character: 10 },
+            selectedText: 'hello',
+          },
+          shouldSendContext: true,
+        },
+        {
+          description: 'sends delta when cursor line changes',
+          previousActiveFile: {
+            path: '/path/to/active/file.ts',
+            cursor: { line: 1, character: 10 },
+            selectedText: 'hello',
+          },
+          currentActiveFile: {
+            path: '/path/to/active/file.ts',
+            cursor: { line: 5, character: 10 },
+            selectedText: 'hello',
+          },
+          shouldSendContext: true,
+        },
+        {
+          description: 'sends delta when cursor character changes',
+          previousActiveFile: {
+            path: '/path/to/active/file.ts',
+            cursor: { line: 5, character: 1 },
+            selectedText: 'hello',
+          },
+          currentActiveFile: {
+            path: '/path/to/active/file.ts',
+            cursor: { line: 5, character: 10 },
+            selectedText: 'hello',
+          },
+          shouldSendContext: true,
+        },
+        {
+          description: 'sends delta when selected text changes',
+          previousActiveFile: {
+            path: '/path/to/active/file.ts',
+            cursor: { line: 5, character: 10 },
+            selectedText: 'world',
+          },
+          currentActiveFile: {
+            path: '/path/to/active/file.ts',
+            cursor: { line: 5, character: 10 },
+            selectedText: 'hello',
+          },
+          shouldSendContext: true,
+        },
+        {
+          description: 'sends delta when selected text is added',
+          previousActiveFile: {
+            path: '/path/to/active/file.ts',
+            cursor: { line: 5, character: 10 },
+          },
+          currentActiveFile: {
+            path: '/path/to/active/file.ts',
+            cursor: { line: 5, character: 10 },
+            selectedText: 'hello',
+          },
+          shouldSendContext: true,
+        },
+        {
+          description: 'sends delta when selected text is removed',
+          previousActiveFile: {
+            path: '/path/to/active/file.ts',
+            cursor: { line: 5, character: 10 },
+            selectedText: 'hello',
+          },
+          currentActiveFile: {
+            path: '/path/to/active/file.ts',
+            cursor: { line: 5, character: 10 },
+          },
+          shouldSendContext: true,
+        },
+        {
+          description: 'does not send context when nothing changes',
+          previousActiveFile: {
+            path: '/path/to/active/file.ts',
+            cursor: { line: 5, character: 10 },
+            selectedText: 'hello',
+          },
+          currentActiveFile: {
+            path: '/path/to/active/file.ts',
+            cursor: { line: 5, character: 10 },
+            selectedText: 'hello',
+          },
+          shouldSendContext: false,
+        },
+      ];
+
+      it.each(testCases)(
+        '$description',
+        async ({
+          previousActiveFile,
+          currentActiveFile,
+          shouldSendContext,
+        }) => {
+          // Setup previous context
+          client['lastSentIdeContext'] = {
+            workspaceState: {
+              openFiles: [
+                {
+                  path: previousActiveFile.path,
+                  cursor: previousActiveFile.cursor,
+                  selectedText: previousActiveFile.selectedText,
+                  isActive: true,
+                  timestamp: Date.now() - 1000,
+                },
+              ],
+            },
+          };
+
+          // Setup current context
+          vi.mocked(ideContext.getIdeContext).mockReturnValue({
+            workspaceState: {
+              openFiles: [
+                { ...currentActiveFile, isActive: true, timestamp: Date.now() },
+              ],
+            },
+          });
+
+          const stream = client.sendMessageStream(
+            [{ text: 'Hi' }],
+            new AbortController().signal,
+            'prompt-id-delta',
+          );
+          for await (const _ of stream) {
+            // consume stream
+          }
+
+          const mockChat = client['chat'] as unknown as {
+            addHistory: (typeof vi)['fn'];
+          };
+
+          if (shouldSendContext) {
+            expect(mockChat.addHistory).toHaveBeenCalledWith(
+              expect.objectContaining({
+                parts: expect.arrayContaining([
+                  expect.objectContaining({
+                    text: expect.stringContaining(
+                      "Here is a summary of changes in the user's editor context",
+                    ),
+                  }),
+                ]),
+              }),
+            );
+          } else {
+            expect(mockChat.addHistory).not.toHaveBeenCalled();
+          }
+        },
+      );
+
+      it('sends full context when history is cleared, even if editor state is unchanged', async () => {
+        const activeFile = {
+          path: '/path/to/active/file.ts',
+          cursor: { line: 5, character: 10 },
+          selectedText: 'hello',
+        };
+
+        // Setup previous context
+        client['lastSentIdeContext'] = {
+          workspaceState: {
+            openFiles: [
+              {
+                path: activeFile.path,
+                cursor: activeFile.cursor,
+                selectedText: activeFile.selectedText,
+                isActive: true,
+                timestamp: Date.now() - 1000,
+              },
+            ],
+          },
+        };
+
+        // Setup current context (same as previous)
+        vi.mocked(ideContext.getIdeContext).mockReturnValue({
+          workspaceState: {
+            openFiles: [
+              { ...activeFile, isActive: true, timestamp: Date.now() },
+            ],
+          },
+        });
+
+        // Make history empty
+        const mockChat = client['chat'] as unknown as {
+          getHistory: ReturnType<(typeof vi)['fn']>;
+          addHistory: ReturnType<(typeof vi)['fn']>;
+        };
+        mockChat.getHistory.mockReturnValue([]);
+
+        const stream = client.sendMessageStream(
+          [{ text: 'Hi' }],
+          new AbortController().signal,
+          'prompt-id-history-cleared',
+        );
+        for await (const _ of stream) {
+          // consume stream
+        }
+
+        expect(mockChat.addHistory).toHaveBeenCalledWith(
+          expect.objectContaining({
+            parts: expect.arrayContaining([
+              expect.objectContaining({
+                text: expect.stringContaining(
+                  "Here is the user's editor context",
+                ),
+              }),
+            ]),
+          }),
+        );
+
+        // Also verify it's the full context, not a delta.
+        const call = mockChat.addHistory.mock.calls[0][0];
+        const contextText = call.parts[0].text;
+        const contextJson = JSON.parse(
+          contextText.match(/```json\n(.*)\n```/s)![1],
+        );
+        expect(contextJson).toHaveProperty('activeFile');
+        expect(contextJson.activeFile.path).toBe('/path/to/active/file.ts');
+      });
+    });
   });
 
   describe('generateContent', () => {
diff --git a/packages/core/src/core/client.ts b/packages/core/src/core/client.ts
index 13e60039..df3dbc4e 100644
--- a/packages/core/src/core/client.ts
+++ b/packages/core/src/core/client.ts
@@ -50,6 +50,7 @@ import {
   NextSpeakerCheckEvent,
 } from '../telemetry/types.js';
 import { ClearcutLogger } from '../telemetry/clearcut-logger/clearcut-logger.js';
+import { IdeContext, File } from '../ide/ideContext.js';
 
 function isThinkingSupported(model: string) {
   if (model.startsWith('gemini-2.5')) return true;
@@ -112,6 +113,8 @@ export class GeminiClient {
 
   private readonly loopDetector: LoopDetectionService;
   private lastPromptId: string;
+  private lastSentIdeContext: IdeContext | undefined;
+  private forceFullIdeContext = true;
 
   constructor(private config: Config) {
     if (config.getProxy()) {
@@ -164,6 +167,7 @@ export class GeminiClient {
 
   setHistory(history: Content[]) {
     this.getChat().setHistory(history);
+    this.forceFullIdeContext = true;
   }
 
   async setTools(): Promise<void> {
@@ -189,6 +193,7 @@ export class GeminiClient {
   }
 
   async startChat(extraHistory?: Content[]): Promise<GeminiChat> {
+    this.forceFullIdeContext = true;
     const envParts = await getEnvironmentContext(this.config);
     const toolRegistry = await this.config.getToolRegistry();
     const toolDeclarations = toolRegistry.getFunctionDeclarations();
@@ -238,6 +243,174 @@ export class GeminiClient {
     }
   }
 
+  private getIdeContextParts(forceFullContext: boolean): {
+    contextParts: string[];
+    newIdeContext: IdeContext | undefined;
+  } {
+    const currentIdeContext = ideContext.getIdeContext();
+    if (!currentIdeContext) {
+      return { contextParts: [], newIdeContext: undefined };
+    }
+
+    if (forceFullContext || !this.lastSentIdeContext) {
+      // Send full context as JSON
+      const openFiles = currentIdeContext.workspaceState?.openFiles || [];
+      const activeFile = openFiles.find((f) => f.isActive);
+      const otherOpenFiles = openFiles
+        .filter((f) => !f.isActive)
+        .map((f) => f.path);
+
+      const contextData: Record<string, unknown> = {};
+
+      if (activeFile) {
+        contextData.activeFile = {
+          path: activeFile.path,
+          cursor: activeFile.cursor
+            ? {
+                line: activeFile.cursor.line,
+                character: activeFile.cursor.character,
+              }
+            : undefined,
+          selectedText: activeFile.selectedText || undefined,
+        };
+      }
+
+      if (otherOpenFiles.length > 0) {
+        contextData.otherOpenFiles = otherOpenFiles;
+      }
+
+      if (Object.keys(contextData).length === 0) {
+        return { contextParts: [], newIdeContext: currentIdeContext };
+      }
+
+      const jsonString = JSON.stringify(contextData, null, 2);
+      const contextParts = [
+        "Here is the user's editor context as a JSON object. This is for your information only.",
+        '```json',
+        jsonString,
+        '```',
+      ];
+
+      if (this.config.getDebugMode()) {
+        console.log(contextParts.join('\n'));
+      }
+      return {
+        contextParts,
+        newIdeContext: currentIdeContext,
+      };
+    } else {
+      // Calculate and send delta as JSON
+      const delta: Record<string, unknown> = {};
+      const changes: Record<string, unknown> = {};
+
+      const lastFiles = new Map(
+        (this.lastSentIdeContext.workspaceState?.openFiles || []).map(
+          (f: File) => [f.path, f],
+        ),
+      );
+      const currentFiles = new Map(
+        (currentIdeContext.workspaceState?.openFiles || []).map((f: File) => [
+          f.path,
+          f,
+        ]),
+      );
+
+      const openedFiles: string[] = [];
+      for (const [path] of currentFiles.entries()) {
+        if (!lastFiles.has(path)) {
+          openedFiles.push(path);
+        }
+      }
+      if (openedFiles.length > 0) {
+        changes.filesOpened = openedFiles;
+      }
+
+      const closedFiles: string[] = [];
+      for (const [path] of lastFiles.entries()) {
+        if (!currentFiles.has(path)) {
+          closedFiles.push(path);
+        }
+      }
+      if (closedFiles.length > 0) {
+        changes.filesClosed = closedFiles;
+      }
+
+      const lastActiveFile = (
+        this.lastSentIdeContext.workspaceState?.openFiles || []
+      ).find((f: File) => f.isActive);
+      const currentActiveFile = (
+        currentIdeContext.workspaceState?.openFiles || []
+      ).find((f: File) => f.isActive);
+
+      if (currentActiveFile) {
+        if (!lastActiveFile || lastActiveFile.path !== currentActiveFile.path) {
+          changes.activeFileChanged = {
+            path: currentActiveFile.path,
+            cursor: currentActiveFile.cursor
+              ? {
+                  line: currentActiveFile.cursor.line,
+                  character: currentActiveFile.cursor.character,
+                }
+              : undefined,
+            selectedText: currentActiveFile.selectedText || undefined,
+          };
+        } else {
+          const lastCursor = lastActiveFile.cursor;
+          const currentCursor = currentActiveFile.cursor;
+          if (
+            currentCursor &&
+            (!lastCursor ||
+              lastCursor.line !== currentCursor.line ||
+              lastCursor.character !== currentCursor.character)
+          ) {
+            changes.cursorMoved = {
+              path: currentActiveFile.path,
+              cursor: {
+                line: currentCursor.line,
+                character: currentCursor.character,
+              },
+            };
+          }
+
+          const lastSelectedText = lastActiveFile.selectedText || '';
+          const currentSelectedText = currentActiveFile.selectedText || '';
+          if (lastSelectedText !== currentSelectedText) {
+            changes.selectionChanged = {
+              path: currentActiveFile.path,
+              selectedText: currentSelectedText,
+            };
+          }
+        }
+      } else if (lastActiveFile) {
+        changes.activeFileChanged = {
+          path: null,
+          previousPath: lastActiveFile.path,
+        };
+      }
+
+      if (Object.keys(changes).length === 0) {
+        return { contextParts: [], newIdeContext: currentIdeContext };
+      }
+
+      delta.changes = changes;
+      const jsonString = JSON.stringify(delta, null, 2);
+      const contextParts = [
+        "Here is a summary of changes in the user's editor context, in JSON format. This is for your information only.",
+        '```json',
+        jsonString,
+        '```',
+      ];
+
+      if (this.config.getDebugMode()) {
+        console.log(contextParts.join('\n'));
+      }
+      return {
+        contextParts,
+        newIdeContext: currentIdeContext,
+      };
+    }
+  }
+
   async *sendMessageStream(
     request: PartListUnion,
     signal: AbortSignal,
@@ -273,49 +446,17 @@ export class GeminiClient {
     }
 
     if (this.config.getIdeModeFeature() && this.config.getIdeMode()) {
-      const ideContextState = ideContext.getIdeContext();
-      const openFiles = ideContextState?.workspaceState?.openFiles;
-
-      if (openFiles && openFiles.length > 0) {
-        const contextParts: string[] = [];
-        const firstFile = openFiles[0];
-        const activeFile = firstFile.isActive ? firstFile : undefined;
-
-        if (activeFile) {
-          contextParts.push(
-            `This is the file that the user is looking at:\n- Path: ${activeFile.path}`,
-          );
-          if (activeFile.cursor) {
-            contextParts.push(
-              `This is the cursor position in the file:\n- Cursor Position: Line ${activeFile.cursor.line}, Character ${activeFile.cursor.character}`,
-            );
-          }
-          if (activeFile.selectedText) {
-            contextParts.push(
-              `This is the selected text in the file:\n- ${activeFile.selectedText}`,
-            );
-          }
-        }
-
-        const otherOpenFiles = activeFile ? openFiles.slice(1) : openFiles;
-
-        if (otherOpenFiles.length > 0) {
-          const recentFiles = otherOpenFiles
-            .map((file) => `- ${file.path}`)
-            .join('\n');
-          const heading = activeFile
-            ? `Here are some other files the user has open, with the most recent at the top:`
-            : `Here are some files the user has open, with the most recent at the top:`;
-          contextParts.push(`${heading}\n${recentFiles}`);
-        }
-
-        if (contextParts.length > 0) {
-          request = [
-            { text: contextParts.join('\n') },
-            ...(Array.isArray(request) ? request : [request]),
-          ];
-        }
+      const { contextParts, newIdeContext } = this.getIdeContextParts(
+        this.forceFullIdeContext || this.getHistory().length === 0,
+      );
+      if (contextParts.length > 0) {
+        this.getChat().addHistory({
+          role: 'user',
+          parts: [{ text: contextParts.join('\n') }],
+        });
       }
+      this.lastSentIdeContext = newIdeContext;
+      this.forceFullIdeContext = false;
     }
 
     const turn = new Turn(this.getChat(), prompt_id);
@@ -648,6 +789,7 @@ export class GeminiClient {
       },
       ...historyToKeep,
     ]);
+    this.forceFullIdeContext = true;
 
     const { totalTokens: newTokenCount } =
       await this.getContentGenerator().countTokens({

From 239ba63d281953179f5ac05d9a70c0783b5a9ec9 Mon Sep 17 00:00:00 2001
From: Tommaso Sciortino <sciortino@gmail.com>
Date: Mon, 11 Aug 2025 11:04:44 -0700
Subject: [PATCH 089/107] Make ProjectIdRequiredError error more lenient
 (#5693)

---
 packages/core/src/code_assist/setup.ts | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)

diff --git a/packages/core/src/code_assist/setup.ts b/packages/core/src/code_assist/setup.ts
index 9c7a8043..02c9406c 100644
--- a/packages/core/src/code_assist/setup.ts
+++ b/packages/core/src/code_assist/setup.ts
@@ -53,9 +53,6 @@ export async function setupUser(client: OAuth2Client): Promise<UserData> {
   }
 
   const tier = getOnboardTier(loadRes);
-  if (tier.userDefinedCloudaicompanionProject && !projectId) {
-    throw new ProjectIdRequiredError();
-  }
 
   const onboardReq: OnboardUserRequest = {
     tierId: tier.id,
@@ -69,8 +66,13 @@ export async function setupUser(client: OAuth2Client): Promise<UserData> {
     await new Promise((f) => setTimeout(f, 5000));
     lroRes = await caServer.onboardUser(onboardReq);
   }
+
+  if (!lroRes.response?.cloudaicompanionProject?.id && !projectId) {
+    throw new ProjectIdRequiredError();
+  }
+
   return {
-    projectId: lroRes.response?.cloudaicompanionProject?.id || '',
+    projectId: lroRes.response?.cloudaicompanionProject?.id || projectId!,
     userTier: tier.id,
   };
 }

From 6390b81646e324bfbb86ccd73247f5d3e2a423f8 Mon Sep 17 00:00:00 2001
From: Gaurav <39389231+gsquared94@users.noreply.github.com>
Date: Mon, 11 Aug 2025 11:48:57 -0700
Subject: [PATCH 090/107] update: issue triage workflows tags duplicate issues
 (#5868)

---
 .../gemini-automated-issue-triage.yml         | 147 ++++++++++++++++++
 .../gemini-scheduled-issue-triage.yml         | 103 ++++++++++++
 2 files changed, 250 insertions(+)

diff --git a/.github/workflows/gemini-automated-issue-triage.yml b/.github/workflows/gemini-automated-issue-triage.yml
index 74904d4c..950d11e8 100644
--- a/.github/workflows/gemini-automated-issue-triage.yml
+++ b/.github/workflows/gemini-automated-issue-triage.yml
@@ -28,6 +28,7 @@ permissions:
   id-token: 'write'
   issues: 'write'
   statuses: 'write'
+  packages: 'read'
 
 jobs:
   triage-issue:
@@ -201,3 +202,149 @@ jobs:
               issue_number: '${{ github.event.issue.number }}',
               body: 'There is a problem with the Gemini CLI issue triaging. Please check the [action logs](${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}) for details.'
             })
+
+  deduplicate-issues:
+    if: >
+      github.repository == 'google-gemini/gemini-cli' &&
+      vars.TRIAGE_DEDUPLICATE_ISSUES != '' &&
+      (github.event_name == 'issues' ||
+       github.event_name == 'workflow_dispatch' ||
+       (github.event_name == 'issue_comment' &&
+       contains(github.event.comment.body, '@gemini-cli /deduplicate') &&
+       (github.event.comment.author_association == 'OWNER' ||
+        github.event.comment.author_association == 'MEMBER' ||
+        github.event.comment.author_association == 'COLLABORATOR')))
+
+    timeout-minutes: 20
+    runs-on: 'ubuntu-latest'
+    steps:
+      - name: 'Checkout repository'
+        uses: 'actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683'
+
+      - name: 'Generate GitHub App Token'
+        id: 'generate_token'
+        uses: 'actions/create-github-app-token@df432ceedc7162793a195dd1713ff69aefc7379e'
+        with:
+          app-id: '${{ secrets.APP_ID }}'
+          private-key: '${{ secrets.PRIVATE_KEY }}'
+
+      - name: Log in to GitHub Container Registry
+        uses: docker/login-action@v3
+        with:
+          registry: ghcr.io
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: 'Run Gemini Issue Deduplication'
+        uses: 'google-github-actions/run-gemini-cli@20351b5ea2b4179431f1ae8918a246a0808f8747'
+        id: 'gemini_issue_deduplication'
+        env:
+          GITHUB_TOKEN: '${{ steps.generate_token.outputs.token }}'
+          ISSUE_TITLE: '${{ github.event.issue.title }}'
+          ISSUE_BODY: '${{ github.event.issue.body }}'
+          ISSUE_NUMBER: '${{ github.event.issue.number }}'
+          REPOSITORY: '${{ github.repository }}'
+          FIRESTORE_PROJECT: '${{ vars.FIRESTORE_PROJECT }}'
+        with:
+          gcp_workload_identity_provider: '${{ vars.GCP_WIF_PROVIDER }}'
+          gcp_project_id: '${{ vars.GOOGLE_CLOUD_PROJECT }}'
+          gcp_location: '${{ vars.GOOGLE_CLOUD_LOCATION }}'
+          gcp_service_account: '${{ vars.SERVICE_ACCOUNT_EMAIL }}'
+          gemini_api_key: '${{ secrets.GEMINI_API_KEY }}'
+          use_vertex_ai: '${{ vars.GOOGLE_GENAI_USE_VERTEXAI }}'
+          use_gemini_code_assist: '${{ vars.GOOGLE_GENAI_USE_GCA }}'
+          settings: |-
+            {
+              "mcpServers": {
+                "issue_deduplication": {
+                  "command": "docker",
+                  "args": [
+                    "run",
+                    "-i",
+                    "--rm",
+                    "--network", "host",
+                    "-e", "GITHUB_TOKEN",
+                    "-e", "GEMINI_API_KEY",
+                    "-e", "DATABASE_TYPE",
+                    "-e", "FIRESTORE_DATABASE_ID",
+                    "-e", "GCP_PROJECT",
+                    "-e", "GOOGLE_APPLICATION_CREDENTIALS=/app/gcp-credentials.json",
+                    "-v", "${GOOGLE_APPLICATION_CREDENTIALS}:/app/gcp-credentials.json",
+                    "ghcr.io/google-gemini/gemini-cli-issue-triage@sha256:e3de1523f6c83aabb3c54b76d08940a2bf42febcb789dd2da6f95169641f94d3"
+                  ],
+                  "env": {
+                    "GITHUB_TOKEN": "${GITHUB_TOKEN}",
+                    "GEMINI_API_KEY": "${{ secrets.GEMINI_API_KEY }}",
+                    "DATABASE_TYPE":"firestore",
+                    "GCP_PROJECT": "${FIRESTORE_PROJECT}",
+                    "FIRESTORE_DATABASE_ID": "(default)",
+                    "GOOGLE_APPLICATION_CREDENTIALS": "${GOOGLE_APPLICATION_CREDENTIALS}"
+                  },
+                  "enabled": true,
+                  "timeout": 600000
+                }
+              },
+              "maxSessionTurns": 25,
+              "coreTools": [
+                "run_shell_command(echo)",
+                "run_shell_command(gh issue comment)",
+                "run_shell_command(gh issue view)",
+                "run_shell_command(gh issue edit)"
+              ],
+              "telemetry": {
+                "enabled": true,
+                "target": "gcp"
+              }
+            }
+          prompt: |-
+            ## Role
+            You are an issue de-duplication assistant. Your goal is to find
+            duplicate issues, label the current issue as a duplicate, and notify
+            the user by commenting on the current issue, while avoiding
+            duplicate comments.
+            ## Steps
+            1.  **Find Potential Duplicates:**
+                - The repository is ${{ github.repository }} and the issue number is ${{ github.event.issue.number }}.
+                - Use the `duplicates` tool with the `repo` and `issue_number` to find potential duplicates for the current issue. Do not use the `threshold` parameter.
+                - If no duplicates are found, you are done.
+                - Print the JSON output from the `duplicates` tool to the logs.
+            2.  **Refine Duplicates List (if necessary):**
+                - If the `duplicates` tool returns between 1 and 14 results, you must refine the list.
+                - For each potential duplicate issue, run `gh issue view <issue-number> --json title,body,comments` to fetch its content.
+                - Also fetch the content of the original issue: `gh issue view "${ISSUE_NUMBER}" --json title,body,comments`.
+                - Carefully analyze the content (title, body, comments) of the original issue and all potential duplicates.
+                - It is very important if the comments on either issue mention that they are not duplicates of each other, to treat them as not duplicates.
+                - Based on your analysis, create a final list containing only the issues you are highly confident are actual duplicates.
+                - If your final list is empty, you are done.
+                - Print to the logs if you omitted any potential duplicates based on your analysis.
+                - If the `duplicates` tool returned 15+ results, use the top 15 matches (based on descending similarity score value) to perform this step.
+            3.  **Format Final Duplicates List:**
+                Format the final list of duplicates into a markdown string.
+                The format should be:
+                "Found possible duplicate issues:\n\n- #${issue_number}\n\nIf you believe this is not a duplicate, please remove the `status/possible-duplicate` label."
+                Add an HTML comment to the end for identification: `<!-- gemini-cli-deduplication -->`
+            4.  **Check for Existing Comment:**
+                - Run `gh issue view "${ISSUE_NUMBER}" --json comments` to get all
+                  comments on the issue.
+                - Look for a comment made by a bot (the author's login often ends in `[bot]`) that contains `<!-- gemini-cli-deduplication -->`.
+                - If you find such a comment, store its `id` and `body`.
+            5.  **Decide Action:**
+                - **If an existing comment is found:**
+                    - Compare the new list of duplicate issues with the list from the existing comment's body.
+                    - If they are the same, do nothing.
+                    - If they are different, edit the existing comment. Use
+                      `gh issue comment "${ISSUE_NUMBER}" --edit-comment <comment-id> --body "..."`.
+                      The new body should be the new list of duplicates, but with the header "Found possible duplicate issues (updated):".
+                - **If no existing comment is found:**
+                    - Create a new comment with the list of duplicates.
+                    - Use `gh issue comment "${ISSUE_NUMBER}" --body "..."`.
+            6.  **Add Duplicate Label:**
+                - If you created or updated a comment in the previous step, add the `duplicate` label to the current issue.
+                - Use `gh issue edit "${ISSUE_NUMBER}" --add-label "status/possible-duplicate"`.
+            ## Guidelines
+            - Only use the `duplicates` and `run_shell_command` tools.
+            - The `run_shell_command` tool can be used with `gh issue view`, `gh issue comment`, and `gh issue edit`.
+            - Do not download or read media files like images, videos, or links. The `--json` flag for `gh issue view` will prevent this.
+            - Do not modify the issue content or status.
+            - Only comment on and label the current issue.
+            - Reference all shell variables as "${VAR}" (with quotes and braces).
diff --git a/.github/workflows/gemini-scheduled-issue-triage.yml b/.github/workflows/gemini-scheduled-issue-triage.yml
index 97a81332..c6553706 100644
--- a/.github/workflows/gemini-scheduled-issue-triage.yml
+++ b/.github/workflows/gemini-scheduled-issue-triage.yml
@@ -18,6 +18,7 @@ permissions:
   id-token: 'write'
   issues: 'write'
   statuses: 'write'
+  packages: 'read'
 
 jobs:
   triage-issues:
@@ -223,3 +224,105 @@ jobs:
               - could also pertain to latency,
               - other general software performance like, memory usage, CPU consumption, and algorithmic efficiency.
               - Switching models from one to the other unexpectedly.
+
+  refresh-embeddings:
+    if: |-
+      ${{ vars.TRIAGE_DEDUPLICATE_ISSUES != '' && github.repository == 'google-gemini/gemini-cli' }}
+    timeout-minutes: 20
+    runs-on: 'ubuntu-latest'
+    steps:
+      - name: 'Checkout repository'
+        uses: 'actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683'
+
+      - name: 'Generate GitHub App Token'
+        id: 'generate_token'
+        uses: 'actions/create-github-app-token@df432ceedc7162793a195dd1713ff69aefc7379e'
+        with:
+          app-id: '${{ secrets.APP_ID }}'
+          private-key: '${{ secrets.PRIVATE_KEY }}'
+
+      - name: Log in to GitHub Container Registry
+        uses: docker/login-action@v3
+        with:
+          registry: ghcr.io
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: 'Run Gemini Issue Deduplication Refresh'
+        uses: 'google-github-actions/run-gemini-cli@20351b5ea2b4179431f1ae8918a246a0808f8747'
+        id: 'gemini_refresh_embeddings'
+        env:
+          GITHUB_TOKEN: '${{ steps.generate_token.outputs.token }}'
+          ISSUE_TITLE: '${{ github.event.issue.title }}'
+          ISSUE_BODY: '${{ github.event.issue.body }}'
+          ISSUE_NUMBER: '${{ github.event.issue.number }}'
+          REPOSITORY: '${{ github.repository }}'
+          FIRESTORE_PROJECT: '${{ vars.FIRESTORE_PROJECT }}'
+        with:
+          gcp_workload_identity_provider: '${{ vars.GCP_WIF_PROVIDER }}'
+          gcp_project_id: '${{ vars.GOOGLE_CLOUD_PROJECT }}'
+          gcp_location: '${{ vars.GOOGLE_CLOUD_LOCATION }}'
+          gcp_service_account: '${{ vars.SERVICE_ACCOUNT_EMAIL }}'
+          gemini_api_key: '${{ secrets.GEMINI_API_KEY }}'
+          use_vertex_ai: '${{ vars.GOOGLE_GENAI_USE_VERTEXAI }}'
+          use_gemini_code_assist: '${{ vars.GOOGLE_GENAI_USE_GCA }}'
+          settings: |-
+            {
+              "mcpServers": {
+                "issue_deduplication": {
+                  "command": "docker",
+                  "args": [
+                    "run",
+                    "-i",
+                    "--rm",
+                    "--network", "host",
+                    "-e", "GITHUB_TOKEN",
+                    "-e", "GEMINI_API_KEY",
+                    "-e", "DATABASE_TYPE",
+                    "-e", "FIRESTORE_DATABASE_ID",
+                    "-e", "GCP_PROJECT",
+                    "-e", "GOOGLE_APPLICATION_CREDENTIALS=/app/gcp-credentials.json",
+                    "-v", "${GOOGLE_APPLICATION_CREDENTIALS}:/app/gcp-credentials.json",
+                    "ghcr.io/google-gemini/gemini-cli-issue-triage@sha256:e3de1523f6c83aabb3c54b76d08940a2bf42febcb789dd2da6f95169641f94d3"
+                  ],
+                  "env": {
+                    "GITHUB_TOKEN": "${GITHUB_TOKEN}",
+                    "GEMINI_API_KEY": "${{ secrets.GEMINI_API_KEY }}",
+                    "DATABASE_TYPE":"firestore",
+                    "GCP_PROJECT": "${FIRESTORE_PROJECT}",
+                    "FIRESTORE_DATABASE_ID": "(default)",
+                    "GOOGLE_APPLICATION_CREDENTIALS": "${GOOGLE_APPLICATION_CREDENTIALS}"
+                  },
+                  "enabled": true,
+                  "timeout": 600000
+                }
+              },
+              "maxSessionTurns": 25,
+              "coreTools": [
+                "run_shell_command(echo)"
+              ],
+              "telemetry": {
+                "enabled": true,
+                "target": "gcp"
+              }
+            }
+          prompt: |-
+            ## Role
+
+            You are a database maintenance assistant for a GitHub issue deduplication system.
+
+            ## Goal
+
+            Your sole responsibility is to refresh the embeddings for all open issues in the repository to ensure the deduplication database is up-to-date.
+
+            ## Steps
+
+            1.  **Extract Repository Information:** The repository is ${{ github.repository }}.
+            2.  **Refresh Embeddings:** Call the `refresh` tool with the correct `repo`. Do not use the `force` parameter.
+            3.  **Log Output:** Print the JSON output from the `refresh` tool to the logs.
+
+            ## Guidelines
+
+            - Only use the `refresh` tool.
+            - Do not attempt to find duplicates or modify any issues.
+            - Your only task is to call the `refresh` tool and log its output.

From 72832fb889729566eb150830d5b1da684963b098 Mon Sep 17 00:00:00 2001
From: Sijie Wang <3463757+sijieamoy@users.noreply.github.com>
Date: Mon, 11 Aug 2025 11:58:32 -0700
Subject: [PATCH 091/107] Fix line end bugs in Vim mode (#5328)

Co-authored-by: Jacob Richman <jacob314@gmail.com>
---
 .../ui/components/shared/text-buffer.test.ts  |  95 ++++
 .../src/ui/components/shared/text-buffer.ts   | 354 +++++++++++----
 .../shared/vim-buffer-actions.test.ts         | 325 +++++++++++++-
 .../components/shared/vim-buffer-actions.ts   | 408 +++++++-----------
 4 files changed, 856 insertions(+), 326 deletions(-)

diff --git a/packages/cli/src/ui/components/shared/text-buffer.test.ts b/packages/cli/src/ui/components/shared/text-buffer.test.ts
index cbceedbc..fb75179e 100644
--- a/packages/cli/src/ui/components/shared/text-buffer.test.ts
+++ b/packages/cli/src/ui/components/shared/text-buffer.test.ts
@@ -15,7 +15,11 @@ import {
   textBufferReducer,
   TextBufferState,
   TextBufferAction,
+  findWordEndInLine,
+  findNextWordStartInLine,
+  isWordCharStrict,
 } from './text-buffer.js';
+import { cpLen } from '../../utils/textUtils.js';
 
 const initialState: TextBufferState = {
   lines: [''],
@@ -1591,3 +1595,94 @@ describe('textBufferReducer vim operations', () => {
     });
   });
 });
+
+describe('Unicode helper functions', () => {
+  describe('findWordEndInLine with Unicode', () => {
+    it('should handle combining characters', () => {
+      // café with combining accent
+      const cafeWithCombining = 'cafe\u0301';
+      const result = findWordEndInLine(cafeWithCombining + ' test', 0);
+      expect(result).toBe(3); // End of 'café' at base character 'e', not combining accent
+    });
+
+    it('should handle precomposed characters with diacritics', () => {
+      // café with precomposed é (U+00E9)
+      const cafePrecomposed = 'café';
+      const result = findWordEndInLine(cafePrecomposed + ' test', 0);
+      expect(result).toBe(3); // End of 'café' at precomposed character 'é'
+    });
+
+    it('should return null when no word end found', () => {
+      const result = findWordEndInLine('   ', 0);
+      expect(result).toBeNull(); // No word end found in whitespace-only string string
+    });
+  });
+
+  describe('findNextWordStartInLine with Unicode', () => {
+    it('should handle right-to-left text', () => {
+      const result = findNextWordStartInLine('hello مرحبا world', 0);
+      expect(result).toBe(6); // Start of Arabic word
+    });
+
+    it('should handle Chinese characters', () => {
+      const result = findNextWordStartInLine('hello 你好 world', 0);
+      expect(result).toBe(6); // Start of Chinese word
+    });
+
+    it('should return null at end of line', () => {
+      const result = findNextWordStartInLine('hello', 10);
+      expect(result).toBeNull();
+    });
+
+    it('should handle combining characters', () => {
+      // café with combining accent + next word
+      const textWithCombining = 'cafe\u0301 test';
+      const result = findNextWordStartInLine(textWithCombining, 0);
+      expect(result).toBe(6); // Start of 'test' after 'café ' (combining char makes string longer)
+    });
+
+    it('should handle precomposed characters with diacritics', () => {
+      // café with precomposed é + next word
+      const textPrecomposed = 'café test';
+      const result = findNextWordStartInLine(textPrecomposed, 0);
+      expect(result).toBe(5); // Start of 'test' after 'café '
+    });
+  });
+
+  describe('isWordCharStrict with Unicode', () => {
+    it('should return true for ASCII word characters', () => {
+      expect(isWordCharStrict('a')).toBe(true);
+      expect(isWordCharStrict('Z')).toBe(true);
+      expect(isWordCharStrict('0')).toBe(true);
+      expect(isWordCharStrict('_')).toBe(true);
+    });
+
+    it('should return false for punctuation', () => {
+      expect(isWordCharStrict('.')).toBe(false);
+      expect(isWordCharStrict(',')).toBe(false);
+      expect(isWordCharStrict('!')).toBe(false);
+    });
+
+    it('should return true for non-Latin scripts', () => {
+      expect(isWordCharStrict('你')).toBe(true); // Chinese character
+      expect(isWordCharStrict('م')).toBe(true); // Arabic character
+    });
+
+    it('should return false for whitespace', () => {
+      expect(isWordCharStrict(' ')).toBe(false);
+      expect(isWordCharStrict('\t')).toBe(false);
+    });
+  });
+
+  describe('cpLen with Unicode', () => {
+    it('should handle combining characters', () => {
+      expect(cpLen('é')).toBe(1); // Precomposed
+      expect(cpLen('e\u0301')).toBe(2); // e + combining acute
+    });
+
+    it('should handle Chinese and Arabic text', () => {
+      expect(cpLen('hello 你好 world')).toBe(14); // 5 + 1 + 2 + 1 + 5 = 14
+      expect(cpLen('hello مرحبا world')).toBe(17);
+    });
+  });
+});
diff --git a/packages/cli/src/ui/components/shared/text-buffer.ts b/packages/cli/src/ui/components/shared/text-buffer.ts
index cf5ce889..d46e52cc 100644
--- a/packages/cli/src/ui/components/shared/text-buffer.ts
+++ b/packages/cli/src/ui/components/shared/text-buffer.ts
@@ -33,143 +33,329 @@ function isWordChar(ch: string | undefined): boolean {
   return !/[\s,.;!?]/.test(ch);
 }
 
-// Vim-specific word boundary functions
-export const findNextWordStart = (
-  text: string,
-  currentOffset: number,
-): number => {
-  let i = currentOffset;
+// Helper functions for line-based word navigation
+export const isWordCharStrict = (char: string): boolean =>
+  /[\w\p{L}\p{N}]/u.test(char); // Matches a single character that is any Unicode letter, any Unicode number, or an underscore
 
-  if (i >= text.length) return i;
+export const isWhitespace = (char: string): boolean => /\s/.test(char);
 
-  const currentChar = text[i];
+// Check if a character is a combining mark (only diacritics for now)
+export const isCombiningMark = (char: string): boolean => /\p{M}/u.test(char);
+
+// Check if a character should be considered part of a word (including combining marks)
+export const isWordCharWithCombining = (char: string): boolean =>
+  isWordCharStrict(char) || isCombiningMark(char);
+
+// Get the script of a character (simplified for common scripts)
+export const getCharScript = (char: string): string => {
+  if (/[\p{Script=Latin}]/u.test(char)) return 'latin'; // All Latin script chars including diacritics
+  if (/[\p{Script=Han}]/u.test(char)) return 'han'; // Chinese
+  if (/[\p{Script=Arabic}]/u.test(char)) return 'arabic';
+  if (/[\p{Script=Hiragana}]/u.test(char)) return 'hiragana';
+  if (/[\p{Script=Katakana}]/u.test(char)) return 'katakana';
+  if (/[\p{Script=Cyrillic}]/u.test(char)) return 'cyrillic';
+  return 'other';
+};
+
+// Check if two characters are from different scripts (indicating word boundary)
+export const isDifferentScript = (char1: string, char2: string): boolean => {
+  if (!isWordCharStrict(char1) || !isWordCharStrict(char2)) return false;
+  return getCharScript(char1) !== getCharScript(char2);
+};
+
+// Find next word start within a line, starting from col
+export const findNextWordStartInLine = (
+  line: string,
+  col: number,
+): number | null => {
+  const chars = toCodePoints(line);
+  let i = col;
+
+  if (i >= chars.length) return null;
+
+  const currentChar = chars[i];
 
   // Skip current word/sequence based on character type
-  if (/\w/.test(currentChar)) {
-    // Skip current word characters
-    while (i < text.length && /\w/.test(text[i])) {
+  if (isWordCharStrict(currentChar)) {
+    while (i < chars.length && isWordCharWithCombining(chars[i])) {
+      // Check for script boundary - if next character is from different script, stop here
+      if (
+        i + 1 < chars.length &&
+        isWordCharStrict(chars[i + 1]) &&
+        isDifferentScript(chars[i], chars[i + 1])
+      ) {
+        i++; // Include current character
+        break; // Stop at script boundary
+      }
       i++;
     }
-  } else if (!/\s/.test(currentChar)) {
-    // Skip current non-word, non-whitespace characters (like "/", ".", etc.)
-    while (i < text.length && !/\w/.test(text[i]) && !/\s/.test(text[i])) {
+  } else if (!isWhitespace(currentChar)) {
+    while (
+      i < chars.length &&
+      !isWordCharStrict(chars[i]) &&
+      !isWhitespace(chars[i])
+    ) {
       i++;
     }
   }
 
   // Skip whitespace
-  while (i < text.length && /\s/.test(text[i])) {
+  while (i < chars.length && isWhitespace(chars[i])) {
     i++;
   }
 
-  // If we reached the end of text and there's no next word,
-  // vim behavior for dw is to delete to the end of the current word
-  if (i >= text.length) {
-    // Go back to find the end of the last word
-    let endOfLastWord = text.length - 1;
-    while (endOfLastWord >= 0 && /\s/.test(text[endOfLastWord])) {
-      endOfLastWord--;
-    }
-    // For dw on last word, return position AFTER the last character to delete entire word
-    return Math.max(currentOffset + 1, endOfLastWord + 1);
-  }
-
-  return i;
+  return i < chars.length ? i : null;
 };
 
-export const findPrevWordStart = (
-  text: string,
-  currentOffset: number,
-): number => {
-  let i = currentOffset;
+// Find previous word start within a line
+export const findPrevWordStartInLine = (
+  line: string,
+  col: number,
+): number | null => {
+  const chars = toCodePoints(line);
+  let i = col;
 
-  // If at beginning of text, return current position
-  if (i <= 0) {
-    return currentOffset;
-  }
+  if (i <= 0) return null;
 
-  // Move back one character to start searching
   i--;
 
   // Skip whitespace moving backwards
-  while (i >= 0 && (text[i] === ' ' || text[i] === '\t' || text[i] === '\n')) {
+  while (i >= 0 && isWhitespace(chars[i])) {
     i--;
   }
 
-  if (i < 0) {
-    return 0; // Reached beginning of text
-  }
+  if (i < 0) return null;
 
-  const charAtI = text[i];
-
-  if (/\w/.test(charAtI)) {
+  if (isWordCharStrict(chars[i])) {
     // We're in a word, move to its beginning
-    while (i >= 0 && /\w/.test(text[i])) {
+    while (i >= 0 && isWordCharStrict(chars[i])) {
+      // Check for script boundary - if previous character is from different script, stop here
+      if (
+        i - 1 >= 0 &&
+        isWordCharStrict(chars[i - 1]) &&
+        isDifferentScript(chars[i], chars[i - 1])
+      ) {
+        return i; // Return current position at script boundary
+      }
       i--;
     }
-    return i + 1; // Return first character of word
+    return i + 1;
   } else {
     // We're in punctuation, move to its beginning
-    while (
-      i >= 0 &&
-      !/\w/.test(text[i]) &&
-      text[i] !== ' ' &&
-      text[i] !== '\t' &&
-      text[i] !== '\n'
-    ) {
+    while (i >= 0 && !isWordCharStrict(chars[i]) && !isWhitespace(chars[i])) {
       i--;
     }
-    return i + 1; // Return first character of punctuation sequence
+    return i + 1;
   }
 };
 
-export const findWordEnd = (text: string, currentOffset: number): number => {
-  let i = currentOffset;
+// Find word end within a line
+export const findWordEndInLine = (line: string, col: number): number | null => {
+  const chars = toCodePoints(line);
+  let i = col;
 
-  // If we're already at the end of a word, advance to next word
-  if (
-    i < text.length &&
-    /\w/.test(text[i]) &&
-    (i + 1 >= text.length || !/\w/.test(text[i + 1]))
-  ) {
-    // We're at the end of a word, move forward to find next word
+  // If we're already at the end of a word (including punctuation sequences), advance to next word
+  // This includes both regular word endings and script boundaries
+  const atEndOfWordChar =
+    i < chars.length &&
+    isWordCharWithCombining(chars[i]) &&
+    (i + 1 >= chars.length ||
+      !isWordCharWithCombining(chars[i + 1]) ||
+      (isWordCharStrict(chars[i]) &&
+        i + 1 < chars.length &&
+        isWordCharStrict(chars[i + 1]) &&
+        isDifferentScript(chars[i], chars[i + 1])));
+
+  const atEndOfPunctuation =
+    i < chars.length &&
+    !isWordCharWithCombining(chars[i]) &&
+    !isWhitespace(chars[i]) &&
+    (i + 1 >= chars.length ||
+      isWhitespace(chars[i + 1]) ||
+      isWordCharWithCombining(chars[i + 1]));
+
+  if (atEndOfWordChar || atEndOfPunctuation) {
+    // We're at the end of a word or punctuation sequence, move forward to find next word
     i++;
-    // Skip whitespace/punctuation to find next word
-    while (i < text.length && !/\w/.test(text[i])) {
+    // Skip whitespace to find next word or punctuation
+    while (i < chars.length && isWhitespace(chars[i])) {
       i++;
     }
   }
 
-  // If we're not on a word character, find the next word
-  if (i < text.length && !/\w/.test(text[i])) {
-    while (i < text.length && !/\w/.test(text[i])) {
+  // If we're not on a word character, find the next word or punctuation sequence
+  if (i < chars.length && !isWordCharWithCombining(chars[i])) {
+    // Skip whitespace to find next word or punctuation
+    while (i < chars.length && isWhitespace(chars[i])) {
       i++;
     }
   }
 
-  // Move to end of current word
-  while (i < text.length && /\w/.test(text[i])) {
-    i++;
+  // Move to end of current word (including combining marks, but stop at script boundaries)
+  let foundWord = false;
+  let lastBaseCharPos = -1;
+
+  if (i < chars.length && isWordCharWithCombining(chars[i])) {
+    // Handle word characters
+    while (i < chars.length && isWordCharWithCombining(chars[i])) {
+      foundWord = true;
+
+      // Track the position of the last base character (not combining mark)
+      if (isWordCharStrict(chars[i])) {
+        lastBaseCharPos = i;
+      }
+
+      // Check if next character is from a different script (word boundary)
+      if (
+        i + 1 < chars.length &&
+        isWordCharStrict(chars[i + 1]) &&
+        isDifferentScript(chars[i], chars[i + 1])
+      ) {
+        i++; // Include current character
+        if (isWordCharStrict(chars[i - 1])) {
+          lastBaseCharPos = i - 1;
+        }
+        break; // Stop at script boundary
+      }
+
+      i++;
+    }
+  } else if (i < chars.length && !isWhitespace(chars[i])) {
+    // Handle punctuation sequences (like ████)
+    while (
+      i < chars.length &&
+      !isWordCharStrict(chars[i]) &&
+      !isWhitespace(chars[i])
+    ) {
+      foundWord = true;
+      lastBaseCharPos = i;
+      i++;
+    }
   }
 
-  // Move back one to be on the last character of the word
-  return Math.max(currentOffset, i - 1);
+  // Only return a position if we actually found a word
+  // Return the position of the last base character, not combining marks
+  if (foundWord && lastBaseCharPos >= col) {
+    return lastBaseCharPos;
+  }
+
+  return null;
 };
 
-// Helper functions for vim operations
-export const getOffsetFromPosition = (
-  row: number,
-  col: number,
+// Find next word across lines
+export const findNextWordAcrossLines = (
   lines: string[],
-): number => {
-  let offset = 0;
-  for (let i = 0; i < row; i++) {
-    offset += lines[i].length + 1; // +1 for newline
+  cursorRow: number,
+  cursorCol: number,
+  searchForWordStart: boolean,
+): { row: number; col: number } | null => {
+  // First try current line
+  const currentLine = lines[cursorRow] || '';
+  const colInCurrentLine = searchForWordStart
+    ? findNextWordStartInLine(currentLine, cursorCol)
+    : findWordEndInLine(currentLine, cursorCol);
+
+  if (colInCurrentLine !== null) {
+    return { row: cursorRow, col: colInCurrentLine };
   }
-  offset += col;
-  return offset;
+
+  // Search subsequent lines
+  for (let row = cursorRow + 1; row < lines.length; row++) {
+    const line = lines[row] || '';
+    const chars = toCodePoints(line);
+
+    // For empty lines, if we haven't found any words yet, return the empty line
+    if (chars.length === 0) {
+      // Check if there are any words in remaining lines
+      let hasWordsInLaterLines = false;
+      for (let laterRow = row + 1; laterRow < lines.length; laterRow++) {
+        const laterLine = lines[laterRow] || '';
+        const laterChars = toCodePoints(laterLine);
+        let firstNonWhitespace = 0;
+        while (
+          firstNonWhitespace < laterChars.length &&
+          isWhitespace(laterChars[firstNonWhitespace])
+        ) {
+          firstNonWhitespace++;
+        }
+        if (firstNonWhitespace < laterChars.length) {
+          hasWordsInLaterLines = true;
+          break;
+        }
+      }
+
+      // If no words in later lines, return the empty line
+      if (!hasWordsInLaterLines) {
+        return { row, col: 0 };
+      }
+      continue;
+    }
+
+    // Find first non-whitespace
+    let firstNonWhitespace = 0;
+    while (
+      firstNonWhitespace < chars.length &&
+      isWhitespace(chars[firstNonWhitespace])
+    ) {
+      firstNonWhitespace++;
+    }
+
+    if (firstNonWhitespace < chars.length) {
+      if (searchForWordStart) {
+        return { row, col: firstNonWhitespace };
+      } else {
+        // For word end, find the end of the first word
+        const endCol = findWordEndInLine(line, firstNonWhitespace);
+        if (endCol !== null) {
+          return { row, col: endCol };
+        }
+      }
+    }
+  }
+
+  return null;
 };
 
+// Find previous word across lines
+export const findPrevWordAcrossLines = (
+  lines: string[],
+  cursorRow: number,
+  cursorCol: number,
+): { row: number; col: number } | null => {
+  // First try current line
+  const currentLine = lines[cursorRow] || '';
+  const colInCurrentLine = findPrevWordStartInLine(currentLine, cursorCol);
+
+  if (colInCurrentLine !== null) {
+    return { row: cursorRow, col: colInCurrentLine };
+  }
+
+  // Search previous lines
+  for (let row = cursorRow - 1; row >= 0; row--) {
+    const line = lines[row] || '';
+    const chars = toCodePoints(line);
+
+    if (chars.length === 0) continue;
+
+    // Find last word start
+    let lastWordStart = chars.length;
+    while (lastWordStart > 0 && isWhitespace(chars[lastWordStart - 1])) {
+      lastWordStart--;
+    }
+
+    if (lastWordStart > 0) {
+      // Find start of this word
+      const wordStart = findPrevWordStartInLine(line, lastWordStart);
+      if (wordStart !== null) {
+        return { row, col: wordStart };
+      }
+    }
+  }
+
+  return null;
+};
+
+// Helper functions for vim line operations
 export const getPositionFromOffsets = (
   startOffset: number,
   endOffset: number,
diff --git a/packages/cli/src/ui/components/shared/vim-buffer-actions.test.ts b/packages/cli/src/ui/components/shared/vim-buffer-actions.test.ts
index 8f7f72ab..a07d8df1 100644
--- a/packages/cli/src/ui/components/shared/vim-buffer-actions.test.ts
+++ b/packages/cli/src/ui/components/shared/vim-buffer-actions.test.ts
@@ -140,6 +140,25 @@ describe('vim-buffer-actions', () => {
         expect(result.cursorRow).toBe(1);
         expect(result.cursorCol).toBe(0);
       });
+
+      it('should skip over combining marks to avoid cursor disappearing', () => {
+        // Test case for combining character cursor disappearing bug
+        // "café test" where é is represented as e + combining acute accent
+        const state = createTestState(['cafe\u0301 test'], 0, 2); // Start at 'f'
+        const action = {
+          type: 'vim_move_right' as const,
+          payload: { count: 1 },
+        };
+
+        const result = handleVimAction(state, action);
+        expect(result).toHaveOnlyValidCharacters();
+        expect(result.cursorCol).toBe(3); // Should be on 'e' of 'café'
+
+        // Move right again - should skip combining mark and land on space
+        const result2 = handleVimAction(result, action);
+        expect(result2).toHaveOnlyValidCharacters();
+        expect(result2.cursorCol).toBe(5); // Should be on space after 'café'
+      });
     });
 
     describe('vim_move_up', () => {
@@ -169,7 +188,7 @@ describe('vim-buffer-actions', () => {
         const result = handleVimAction(state, action);
         expect(result).toHaveOnlyValidCharacters();
         expect(result.cursorRow).toBe(0);
-        expect(result.cursorCol).toBe(5); // End of 'short'
+        expect(result.cursorCol).toBe(4); // Last character 't' of 'short', not past it
       });
     });
 
@@ -236,6 +255,20 @@ describe('vim-buffer-actions', () => {
         expect(result).toHaveOnlyValidCharacters();
         expect(result.cursorCol).toBe(5); // Start of ','
       });
+
+      it('should move across empty lines when starting from within a word', () => {
+        // Testing the exact scenario: cursor on 'w' of 'hello world', w should move to next line
+        const state = createTestState(['hello world', ''], 0, 6); // At 'w' of 'world'
+        const action = {
+          type: 'vim_move_word_forward' as const,
+          payload: { count: 1 },
+        };
+
+        const result = handleVimAction(state, action);
+        expect(result).toHaveOnlyValidCharacters();
+        expect(result.cursorRow).toBe(1); // Should move to empty line
+        expect(result.cursorCol).toBe(0); // Beginning of empty line
+      });
     });
 
     describe('vim_move_word_backward', () => {
@@ -288,6 +321,85 @@ describe('vim-buffer-actions', () => {
         expect(result).toHaveOnlyValidCharacters();
         expect(result.cursorCol).toBe(10); // End of 'world'
       });
+
+      it('should move across empty lines when at word end', () => {
+        const state = createTestState(['hello world', '', 'test'], 0, 10); // At 'd' of 'world'
+        const action = {
+          type: 'vim_move_word_end' as const,
+          payload: { count: 1 },
+        };
+
+        const result = handleVimAction(state, action);
+        expect(result).toHaveOnlyValidCharacters();
+        expect(result.cursorRow).toBe(2); // Should move to line with 'test'
+        expect(result.cursorCol).toBe(3); // Should be at 't' (end of 'test')
+      });
+
+      it('should handle consecutive word-end movements across empty lines', () => {
+        // Testing the exact scenario: cursor on 'w' of world, press 'e' twice
+        const state = createTestState(['hello world', ''], 0, 6); // At 'w' of 'world'
+
+        // First 'e' should move to 'd' of 'world'
+        let result = handleVimAction(state, {
+          type: 'vim_move_word_end' as const,
+          payload: { count: 1 },
+        });
+        expect(result).toHaveOnlyValidCharacters();
+        expect(result.cursorRow).toBe(0);
+        expect(result.cursorCol).toBe(10); // At 'd' of 'world'
+
+        // Second 'e' should move to the empty line (end of file in this case)
+        result = handleVimAction(result, {
+          type: 'vim_move_word_end' as const,
+          payload: { count: 1 },
+        });
+        expect(result).toHaveOnlyValidCharacters();
+        expect(result.cursorRow).toBe(1); // Should move to empty line
+        expect(result.cursorCol).toBe(0); // Empty line has col 0
+      });
+
+      it('should handle combining characters - advance from end of base character', () => {
+        // Test case for combining character word end bug
+        // "café test" where é is represented as e + combining acute accent
+        const state = createTestState(['cafe\u0301 test'], 0, 0); // Start at 'c'
+
+        // First 'e' command should move to the 'e' (position 3)
+        let result = handleVimAction(state, {
+          type: 'vim_move_word_end' as const,
+          payload: { count: 1 },
+        });
+        expect(result).toHaveOnlyValidCharacters();
+        expect(result.cursorCol).toBe(3); // At 'e' of café
+
+        // Second 'e' command should advance to end of "test" (position 9), not stay stuck
+        result = handleVimAction(result, {
+          type: 'vim_move_word_end' as const,
+          payload: { count: 1 },
+        });
+        expect(result).toHaveOnlyValidCharacters();
+        expect(result.cursorCol).toBe(9); // At 't' of "test"
+      });
+
+      it('should handle precomposed characters with diacritics', () => {
+        // Test case with precomposed é for comparison
+        const state = createTestState(['café test'], 0, 0); // Start at 'c'
+
+        // First 'e' command should move to the 'é' (position 3)
+        let result = handleVimAction(state, {
+          type: 'vim_move_word_end' as const,
+          payload: { count: 1 },
+        });
+        expect(result).toHaveOnlyValidCharacters();
+        expect(result.cursorCol).toBe(3); // At 'é' of café
+
+        // Second 'e' command should advance to end of "test" (position 8)
+        result = handleVimAction(result, {
+          type: 'vim_move_word_end' as const,
+          payload: { count: 1 },
+        });
+        expect(result).toHaveOnlyValidCharacters();
+        expect(result.cursorCol).toBe(8); // At 't' of "test"
+      });
     });
 
     describe('Position commands', () => {
@@ -793,4 +905,215 @@ describe('vim-buffer-actions', () => {
       expect(result.undoStack).toHaveLength(2); // Original plus new snapshot
     });
   });
+
+  describe('UTF-32 character handling in word/line operations', () => {
+    describe('Right-to-left text handling', () => {
+      it('should handle Arabic text in word movements', () => {
+        const state = createTestState(['hello مرحبا world'], 0, 0);
+
+        // Move to end of 'hello'
+        let result = handleVimAction(state, {
+          type: 'vim_move_word_end' as const,
+          payload: { count: 1 },
+        });
+        expect(result).toHaveOnlyValidCharacters();
+        expect(result.cursorCol).toBe(4); // End of 'hello'
+
+        // Move to end of Arabic word
+        result = handleVimAction(result, {
+          type: 'vim_move_word_end' as const,
+          payload: { count: 1 },
+        });
+        expect(result).toHaveOnlyValidCharacters();
+        expect(result.cursorCol).toBe(10); // End of Arabic word 'مرحبا'
+      });
+    });
+
+    describe('Chinese character handling', () => {
+      it('should handle Chinese characters in word movements', () => {
+        const state = createTestState(['hello 你好 world'], 0, 0);
+
+        // Move to end of 'hello'
+        let result = handleVimAction(state, {
+          type: 'vim_move_word_end' as const,
+          payload: { count: 1 },
+        });
+        expect(result).toHaveOnlyValidCharacters();
+        expect(result.cursorCol).toBe(4); // End of 'hello'
+
+        // Move forward to start of 'world'
+        result = handleVimAction(result, {
+          type: 'vim_move_word_forward' as const,
+          payload: { count: 1 },
+        });
+        expect(result).toHaveOnlyValidCharacters();
+        expect(result.cursorCol).toBe(6); // Start of '你好'
+      });
+    });
+
+    describe('Mixed script handling', () => {
+      it('should handle mixed Latin and non-Latin scripts with word end commands', () => {
+        const state = createTestState(['test中文test'], 0, 0);
+
+        let result = handleVimAction(state, {
+          type: 'vim_move_word_end' as const,
+          payload: { count: 1 },
+        });
+        expect(result).toHaveOnlyValidCharacters();
+        expect(result.cursorCol).toBe(3); // End of 'test'
+
+        // Second word end command should move to end of '中文'
+        result = handleVimAction(result, {
+          type: 'vim_move_word_end' as const,
+          payload: { count: 1 },
+        });
+        expect(result).toHaveOnlyValidCharacters();
+        expect(result.cursorCol).toBe(5); // End of '中文'
+      });
+
+      it('should handle mixed Latin and non-Latin scripts with word forward commands', () => {
+        const state = createTestState(['test中文test'], 0, 0);
+
+        let result = handleVimAction(state, {
+          type: 'vim_move_word_forward' as const,
+          payload: { count: 1 },
+        });
+        expect(result).toHaveOnlyValidCharacters();
+        expect(result.cursorCol).toBe(4); // Start of '中'
+
+        // Second word forward command should move to start of final 'test'
+        result = handleVimAction(result, {
+          type: 'vim_move_word_forward' as const,
+          payload: { count: 1 },
+        });
+        expect(result).toHaveOnlyValidCharacters();
+        expect(result.cursorCol).toBe(6); // Start of final 'test'
+      });
+
+      it('should handle mixed Latin and non-Latin scripts with word backward commands', () => {
+        const state = createTestState(['test中文test'], 0, 9); // Start at end of final 'test'
+
+        let result = handleVimAction(state, {
+          type: 'vim_move_word_backward' as const,
+          payload: { count: 1 },
+        });
+        expect(result).toHaveOnlyValidCharacters();
+        expect(result.cursorCol).toBe(6); // Start of final 'test'
+
+        // Second word backward command should move to start of '中文'
+        result = handleVimAction(result, {
+          type: 'vim_move_word_backward' as const,
+          payload: { count: 1 },
+        });
+        expect(result).toHaveOnlyValidCharacters();
+        expect(result.cursorCol).toBe(4); // Start of '中'
+      });
+
+      it('should handle Unicode block characters consistently with w and e commands', () => {
+        const state = createTestState(['██ █████ ██'], 0, 0);
+
+        // Test w command progression
+        let wResult = handleVimAction(state, {
+          type: 'vim_move_word_forward' as const,
+          payload: { count: 1 },
+        });
+        expect(wResult).toHaveOnlyValidCharacters();
+        expect(wResult.cursorCol).toBe(3); // Start of second block sequence
+
+        wResult = handleVimAction(wResult, {
+          type: 'vim_move_word_forward' as const,
+          payload: { count: 1 },
+        });
+        expect(wResult).toHaveOnlyValidCharacters();
+        expect(wResult.cursorCol).toBe(9); // Start of third block sequence
+
+        // Test e command progression from beginning
+        let eResult = handleVimAction(state, {
+          type: 'vim_move_word_end' as const,
+          payload: { count: 1 },
+        });
+        expect(eResult).toHaveOnlyValidCharacters();
+        expect(eResult.cursorCol).toBe(1); // End of first block sequence
+
+        eResult = handleVimAction(eResult, {
+          type: 'vim_move_word_end' as const,
+          payload: { count: 1 },
+        });
+        expect(eResult).toHaveOnlyValidCharacters();
+        expect(eResult.cursorCol).toBe(7); // End of second block sequence
+
+        eResult = handleVimAction(eResult, {
+          type: 'vim_move_word_end' as const,
+          payload: { count: 1 },
+        });
+        expect(eResult).toHaveOnlyValidCharacters();
+        expect(eResult.cursorCol).toBe(10); // End of third block sequence
+      });
+
+      it('should handle strings starting with Chinese characters', () => {
+        const state = createTestState(['中文test英文word'], 0, 0);
+
+        // Test 'w' command - when at start of non-Latin word, w moves to next word
+        let wResult = handleVimAction(state, {
+          type: 'vim_move_word_forward' as const,
+          payload: { count: 1 },
+        });
+        expect(wResult).toHaveOnlyValidCharacters();
+        expect(wResult.cursorCol).toBe(2); // Start of 'test'
+
+        wResult = handleVimAction(wResult, {
+          type: 'vim_move_word_forward' as const,
+          payload: { count: 1 },
+        });
+        expect(wResult.cursorCol).toBe(6); // Start of '英文'
+
+        // Test 'e' command
+        let eResult = handleVimAction(state, {
+          type: 'vim_move_word_end' as const,
+          payload: { count: 1 },
+        });
+        expect(eResult).toHaveOnlyValidCharacters();
+        expect(eResult.cursorCol).toBe(1); // End of 中文
+
+        eResult = handleVimAction(eResult, {
+          type: 'vim_move_word_end' as const,
+          payload: { count: 1 },
+        });
+        expect(eResult.cursorCol).toBe(5); // End of test
+      });
+
+      it('should handle strings starting with Arabic characters', () => {
+        const state = createTestState(['مرحباhelloسلام'], 0, 0);
+
+        // Test 'w' command - when at start of non-Latin word, w moves to next word
+        let wResult = handleVimAction(state, {
+          type: 'vim_move_word_forward' as const,
+          payload: { count: 1 },
+        });
+        expect(wResult).toHaveOnlyValidCharacters();
+        expect(wResult.cursorCol).toBe(5); // Start of 'hello'
+
+        wResult = handleVimAction(wResult, {
+          type: 'vim_move_word_forward' as const,
+          payload: { count: 1 },
+        });
+        expect(wResult.cursorCol).toBe(10); // Start of 'سلام'
+
+        // Test 'b' command from end
+        const bState = createTestState(['مرحباhelloسلام'], 0, 13);
+        let bResult = handleVimAction(bState, {
+          type: 'vim_move_word_backward' as const,
+          payload: { count: 1 },
+        });
+        expect(bResult).toHaveOnlyValidCharacters();
+        expect(bResult.cursorCol).toBe(10); // Start of سلام
+
+        bResult = handleVimAction(bResult, {
+          type: 'vim_move_word_backward' as const,
+          payload: { count: 1 },
+        });
+        expect(bResult.cursorCol).toBe(5); // Start of hello
+      });
+    });
+  });
 });
diff --git a/packages/cli/src/ui/components/shared/vim-buffer-actions.ts b/packages/cli/src/ui/components/shared/vim-buffer-actions.ts
index ab52e991..0e2e7989 100644
--- a/packages/cli/src/ui/components/shared/vim-buffer-actions.ts
+++ b/packages/cli/src/ui/components/shared/vim-buffer-actions.ts
@@ -7,16 +7,35 @@
 import {
   TextBufferState,
   TextBufferAction,
-  findNextWordStart,
-  findPrevWordStart,
-  findWordEnd,
-  getOffsetFromPosition,
-  getPositionFromOffsets,
   getLineRangeOffsets,
+  getPositionFromOffsets,
   replaceRangeInternal,
   pushUndo,
+  isWordCharStrict,
+  isWordCharWithCombining,
+  isCombiningMark,
+  findNextWordAcrossLines,
+  findPrevWordAcrossLines,
+  findWordEndInLine,
 } from './text-buffer.js';
-import { cpLen } from '../../utils/textUtils.js';
+import { cpLen, toCodePoints } from '../../utils/textUtils.js';
+
+// Check if we're at the end of a base word (on the last base character)
+// Returns true if current position has a base character followed only by combining marks until non-word
+function isAtEndOfBaseWord(lineCodePoints: string[], col: number): boolean {
+  if (!isWordCharStrict(lineCodePoints[col])) return false;
+
+  // Look ahead to see if we have only combining marks followed by non-word
+  let i = col + 1;
+
+  // Skip any combining marks
+  while (i < lineCodePoints.length && isCombiningMark(lineCodePoints[i])) {
+    i++;
+  }
+
+  // If we hit end of line or non-word character, we were at end of base word
+  return i >= lineCodePoints.length || !isWordCharStrict(lineCodePoints[i]);
+}
 
 export type VimAction = Extract<
   TextBufferAction,
@@ -59,167 +78,38 @@ export function handleVimAction(
   action: VimAction,
 ): TextBufferState {
   const { lines, cursorRow, cursorCol } = state;
-  // Cache text join to avoid repeated calculations for word operations
-  let text: string | null = null;
-  const getText = () => text ?? (text = lines.join('\n'));
 
   switch (action.type) {
-    case 'vim_delete_word_forward': {
-      const { count } = action.payload;
-      const currentOffset = getOffsetFromPosition(cursorRow, cursorCol, lines);
-
-      let endOffset = currentOffset;
-      let searchOffset = currentOffset;
-
-      for (let i = 0; i < count; i++) {
-        const nextWordOffset = findNextWordStart(getText(), searchOffset);
-        if (nextWordOffset > searchOffset) {
-          searchOffset = nextWordOffset;
-          endOffset = nextWordOffset;
-        } else {
-          // If no next word, delete to end of current word
-          const wordEndOffset = findWordEnd(getText(), searchOffset);
-          endOffset = Math.min(wordEndOffset + 1, getText().length);
-          break;
-        }
-      }
-
-      if (endOffset > currentOffset) {
-        const nextState = pushUndo(state);
-        const { startRow, startCol, endRow, endCol } = getPositionFromOffsets(
-          currentOffset,
-          endOffset,
-          nextState.lines,
-        );
-        return replaceRangeInternal(
-          nextState,
-          startRow,
-          startCol,
-          endRow,
-          endCol,
-          '',
-        );
-      }
-      return state;
-    }
-
-    case 'vim_delete_word_backward': {
-      const { count } = action.payload;
-      const currentOffset = getOffsetFromPosition(cursorRow, cursorCol, lines);
-
-      let startOffset = currentOffset;
-      let searchOffset = currentOffset;
-
-      for (let i = 0; i < count; i++) {
-        const prevWordOffset = findPrevWordStart(getText(), searchOffset);
-        if (prevWordOffset < searchOffset) {
-          searchOffset = prevWordOffset;
-          startOffset = prevWordOffset;
-        } else {
-          break;
-        }
-      }
-
-      if (startOffset < currentOffset) {
-        const nextState = pushUndo(state);
-        const { startRow, startCol, endRow, endCol } = getPositionFromOffsets(
-          startOffset,
-          currentOffset,
-          nextState.lines,
-        );
-        const newState = replaceRangeInternal(
-          nextState,
-          startRow,
-          startCol,
-          endRow,
-          endCol,
-          '',
-        );
-        // Cursor is already at the correct position after deletion
-        return newState;
-      }
-      return state;
-    }
-
-    case 'vim_delete_word_end': {
-      const { count } = action.payload;
-      const currentOffset = getOffsetFromPosition(cursorRow, cursorCol, lines);
-
-      let offset = currentOffset;
-      let endOffset = currentOffset;
-
-      for (let i = 0; i < count; i++) {
-        const wordEndOffset = findWordEnd(getText(), offset);
-        if (wordEndOffset >= offset) {
-          endOffset = wordEndOffset + 1; // Include the character at word end
-          // For next iteration, move to start of next word
-          if (i < count - 1) {
-            const nextWordStart = findNextWordStart(
-              getText(),
-              wordEndOffset + 1,
-            );
-            offset = nextWordStart;
-            if (nextWordStart <= wordEndOffset) {
-              break; // No more words
-            }
-          }
-        } else {
-          break;
-        }
-      }
-
-      endOffset = Math.min(endOffset, getText().length);
-
-      if (endOffset > currentOffset) {
-        const nextState = pushUndo(state);
-        const { startRow, startCol, endRow, endCol } = getPositionFromOffsets(
-          currentOffset,
-          endOffset,
-          nextState.lines,
-        );
-        return replaceRangeInternal(
-          nextState,
-          startRow,
-          startCol,
-          endRow,
-          endCol,
-          '',
-        );
-      }
-      return state;
-    }
-
+    case 'vim_delete_word_forward':
     case 'vim_change_word_forward': {
       const { count } = action.payload;
-      const currentOffset = getOffsetFromPosition(cursorRow, cursorCol, lines);
-
-      let searchOffset = currentOffset;
-      let endOffset = currentOffset;
+      let endRow = cursorRow;
+      let endCol = cursorCol;
 
       for (let i = 0; i < count; i++) {
-        const nextWordOffset = findNextWordStart(getText(), searchOffset);
-        if (nextWordOffset > searchOffset) {
-          searchOffset = nextWordOffset;
-          endOffset = nextWordOffset;
+        const nextWord = findNextWordAcrossLines(lines, endRow, endCol, true);
+        if (nextWord) {
+          endRow = nextWord.row;
+          endCol = nextWord.col;
         } else {
-          // If no next word, change to end of current word
-          const wordEndOffset = findWordEnd(getText(), searchOffset);
-          endOffset = Math.min(wordEndOffset + 1, getText().length);
+          // No more words, delete/change to end of current word or line
+          const currentLine = lines[endRow] || '';
+          const wordEnd = findWordEndInLine(currentLine, endCol);
+          if (wordEnd !== null) {
+            endCol = wordEnd + 1; // Include the character at word end
+          } else {
+            endCol = cpLen(currentLine);
+          }
           break;
         }
       }
 
-      if (endOffset > currentOffset) {
+      if (endRow !== cursorRow || endCol !== cursorCol) {
         const nextState = pushUndo(state);
-        const { startRow, startCol, endRow, endCol } = getPositionFromOffsets(
-          currentOffset,
-          endOffset,
-          nextState.lines,
-        );
         return replaceRangeInternal(
           nextState,
-          startRow,
-          startCol,
+          cursorRow,
+          cursorCol,
           endRow,
           endCol,
           '',
@@ -228,61 +118,61 @@ export function handleVimAction(
       return state;
     }
 
+    case 'vim_delete_word_backward':
     case 'vim_change_word_backward': {
       const { count } = action.payload;
-      const currentOffset = getOffsetFromPosition(cursorRow, cursorCol, lines);
-
-      let startOffset = currentOffset;
-      let searchOffset = currentOffset;
+      let startRow = cursorRow;
+      let startCol = cursorCol;
 
       for (let i = 0; i < count; i++) {
-        const prevWordOffset = findPrevWordStart(getText(), searchOffset);
-        if (prevWordOffset < searchOffset) {
-          searchOffset = prevWordOffset;
-          startOffset = prevWordOffset;
+        const prevWord = findPrevWordAcrossLines(lines, startRow, startCol);
+        if (prevWord) {
+          startRow = prevWord.row;
+          startCol = prevWord.col;
         } else {
           break;
         }
       }
 
-      if (startOffset < currentOffset) {
+      if (startRow !== cursorRow || startCol !== cursorCol) {
         const nextState = pushUndo(state);
-        const { startRow, startCol, endRow, endCol } = getPositionFromOffsets(
-          startOffset,
-          currentOffset,
-          nextState.lines,
-        );
         return replaceRangeInternal(
           nextState,
           startRow,
           startCol,
-          endRow,
-          endCol,
+          cursorRow,
+          cursorCol,
           '',
         );
       }
       return state;
     }
 
+    case 'vim_delete_word_end':
     case 'vim_change_word_end': {
       const { count } = action.payload;
-      const currentOffset = getOffsetFromPosition(cursorRow, cursorCol, lines);
-
-      let offset = currentOffset;
-      let endOffset = currentOffset;
+      let row = cursorRow;
+      let col = cursorCol;
+      let endRow = cursorRow;
+      let endCol = cursorCol;
 
       for (let i = 0; i < count; i++) {
-        const wordEndOffset = findWordEnd(getText(), offset);
-        if (wordEndOffset >= offset) {
-          endOffset = wordEndOffset + 1; // Include the character at word end
+        const wordEnd = findNextWordAcrossLines(lines, row, col, false);
+        if (wordEnd) {
+          endRow = wordEnd.row;
+          endCol = wordEnd.col + 1; // Include the character at word end
           // For next iteration, move to start of next word
           if (i < count - 1) {
-            const nextWordStart = findNextWordStart(
-              getText(),
-              wordEndOffset + 1,
+            const nextWord = findNextWordAcrossLines(
+              lines,
+              wordEnd.row,
+              wordEnd.col + 1,
+              true,
             );
-            offset = nextWordStart;
-            if (nextWordStart <= wordEndOffset) {
+            if (nextWord) {
+              row = nextWord.row;
+              col = nextWord.col;
+            } else {
               break; // No more words
             }
           }
@@ -291,19 +181,18 @@ export function handleVimAction(
         }
       }
 
-      endOffset = Math.min(endOffset, getText().length);
+      // Ensure we don't go past the end of the last line
+      if (endRow < lines.length) {
+        const lineLen = cpLen(lines[endRow] || '');
+        endCol = Math.min(endCol, lineLen);
+      }
 
-      if (endOffset !== currentOffset) {
+      if (endRow !== cursorRow || endCol !== cursorCol) {
         const nextState = pushUndo(state);
-        const { startRow, startCol, endRow, endCol } = getPositionFromOffsets(
-          Math.min(currentOffset, endOffset),
-          Math.max(currentOffset, endOffset),
-          nextState.lines,
-        );
         return replaceRangeInternal(
           nextState,
-          startRow,
-          startCol,
+          cursorRow,
+          cursorCol,
           endRow,
           endCol,
           '',
@@ -376,32 +265,17 @@ export function handleVimAction(
       );
     }
 
-    case 'vim_delete_to_end_of_line': {
-      const currentLine = lines[cursorRow] || '';
-      if (cursorCol < currentLine.length) {
-        const nextState = pushUndo(state);
-        return replaceRangeInternal(
-          nextState,
-          cursorRow,
-          cursorCol,
-          cursorRow,
-          currentLine.length,
-          '',
-        );
-      }
-      return state;
-    }
-
+    case 'vim_delete_to_end_of_line':
     case 'vim_change_to_end_of_line': {
       const currentLine = lines[cursorRow] || '';
-      if (cursorCol < currentLine.length) {
+      if (cursorCol < cpLen(currentLine)) {
         const nextState = pushUndo(state);
         return replaceRangeInternal(
           nextState,
           cursorRow,
           cursorCol,
           cursorRow,
-          currentLine.length,
+          cpLen(currentLine),
           '',
         );
       }
@@ -578,6 +452,16 @@ export function handleVimAction(
           }
         } else if (newCol < lineLength - 1) {
           newCol++;
+
+          // Skip over combining marks - don't let cursor land on them
+          const currentLinePoints = toCodePoints(currentLine);
+          while (
+            newCol < currentLinePoints.length &&
+            isCombiningMark(currentLinePoints[newCol]) &&
+            newCol < lineLength - 1
+          ) {
+            newCol++;
+          }
         } else if (newRow < lines.length - 1) {
           // At end of line - move to beginning of next line
           newRow++;
@@ -597,7 +481,12 @@ export function handleVimAction(
       const { count } = action.payload;
       const { cursorRow, cursorCol, lines } = state;
       const newRow = Math.max(0, cursorRow - count);
-      const newCol = Math.min(cursorCol, cpLen(lines[newRow] || ''));
+      const targetLine = lines[newRow] || '';
+      const targetLineLength = cpLen(targetLine);
+      const newCol = Math.min(
+        cursorCol,
+        targetLineLength > 0 ? targetLineLength - 1 : 0,
+      );
 
       return {
         ...state,
@@ -611,7 +500,12 @@ export function handleVimAction(
       const { count } = action.payload;
       const { cursorRow, cursorCol, lines } = state;
       const newRow = Math.min(lines.length - 1, cursorRow + count);
-      const newCol = Math.min(cursorCol, cpLen(lines[newRow] || ''));
+      const targetLine = lines[newRow] || '';
+      const targetLineLength = cpLen(targetLine);
+      const newCol = Math.min(
+        cursorCol,
+        targetLineLength > 0 ? targetLineLength - 1 : 0,
+      );
 
       return {
         ...state,
@@ -623,69 +517,101 @@ export function handleVimAction(
 
     case 'vim_move_word_forward': {
       const { count } = action.payload;
-      let offset = getOffsetFromPosition(cursorRow, cursorCol, lines);
+      let row = cursorRow;
+      let col = cursorCol;
 
       for (let i = 0; i < count; i++) {
-        const nextWordOffset = findNextWordStart(getText(), offset);
-        if (nextWordOffset > offset) {
-          offset = nextWordOffset;
+        const nextWord = findNextWordAcrossLines(lines, row, col, true);
+        if (nextWord) {
+          row = nextWord.row;
+          col = nextWord.col;
         } else {
           // No more words to move to
           break;
         }
       }
 
-      const { startRow, startCol } = getPositionFromOffsets(
-        offset,
-        offset,
-        lines,
-      );
       return {
         ...state,
-        cursorRow: startRow,
-        cursorCol: startCol,
+        cursorRow: row,
+        cursorCol: col,
         preferredCol: null,
       };
     }
 
     case 'vim_move_word_backward': {
       const { count } = action.payload;
-      let offset = getOffsetFromPosition(cursorRow, cursorCol, lines);
+      let row = cursorRow;
+      let col = cursorCol;
 
       for (let i = 0; i < count; i++) {
-        offset = findPrevWordStart(getText(), offset);
+        const prevWord = findPrevWordAcrossLines(lines, row, col);
+        if (prevWord) {
+          row = prevWord.row;
+          col = prevWord.col;
+        } else {
+          break;
+        }
       }
 
-      const { startRow, startCol } = getPositionFromOffsets(
-        offset,
-        offset,
-        lines,
-      );
       return {
         ...state,
-        cursorRow: startRow,
-        cursorCol: startCol,
+        cursorRow: row,
+        cursorCol: col,
         preferredCol: null,
       };
     }
 
     case 'vim_move_word_end': {
       const { count } = action.payload;
-      let offset = getOffsetFromPosition(cursorRow, cursorCol, lines);
+      let row = cursorRow;
+      let col = cursorCol;
 
       for (let i = 0; i < count; i++) {
-        offset = findWordEnd(getText(), offset);
+        // Special handling for the first iteration when we're at end of word
+        if (i === 0) {
+          const currentLine = lines[row] || '';
+          const lineCodePoints = toCodePoints(currentLine);
+
+          // Check if we're at the end of a word (on the last base character)
+          const atEndOfWord =
+            col < lineCodePoints.length &&
+            isWordCharStrict(lineCodePoints[col]) &&
+            (col + 1 >= lineCodePoints.length ||
+              !isWordCharWithCombining(lineCodePoints[col + 1]) ||
+              // Or if we're on a base char followed only by combining marks until non-word
+              (isWordCharStrict(lineCodePoints[col]) &&
+                isAtEndOfBaseWord(lineCodePoints, col)));
+
+          if (atEndOfWord) {
+            // We're already at end of word, find next word end
+            const nextWord = findNextWordAcrossLines(
+              lines,
+              row,
+              col + 1,
+              false,
+            );
+            if (nextWord) {
+              row = nextWord.row;
+              col = nextWord.col;
+              continue;
+            }
+          }
+        }
+
+        const wordEnd = findNextWordAcrossLines(lines, row, col, false);
+        if (wordEnd) {
+          row = wordEnd.row;
+          col = wordEnd.col;
+        } else {
+          break;
+        }
       }
 
-      const { startRow, startCol } = getPositionFromOffsets(
-        offset,
-        offset,
-        lines,
-      );
       return {
         ...state,
-        cursorRow: startRow,
-        cursorCol: startCol,
+        cursorRow: row,
+        cursorCol: col,
         preferredCol: null,
       };
     }
@@ -783,7 +709,7 @@ export function handleVimAction(
       let col = 0;
 
       // Find first non-whitespace character using proper Unicode handling
-      const lineCodePoints = [...currentLine]; // Proper Unicode iteration
+      const lineCodePoints = toCodePoints(currentLine);
       while (col < lineCodePoints.length && /\s/.test(lineCodePoints[col])) {
         col++;
       }
@@ -820,7 +746,7 @@ export function handleVimAction(
       let col = 0;
 
       // Find first non-whitespace character using proper Unicode handling
-      const lineCodePoints = [...currentLine]; // Proper Unicode iteration
+      const lineCodePoints = toCodePoints(currentLine);
       while (col < lineCodePoints.length && /\s/.test(lineCodePoints[col])) {
         col++;
       }

From 110e00178bd5f58e66dd2b5182b8c6818b7e590a Mon Sep 17 00:00:00 2001
From: cornmander <shikhman@google.com>
Date: Mon, 11 Aug 2025 15:09:12 -0400
Subject: [PATCH 092/107] Add --experimental-cli to speed up prettier
 formatting. (#5999)

Co-authored-by: Seth Troisi <sethtroisi@google.com>
Co-authored-by: matt korwel <matt.korwel@gmail.com>
---
 package.json | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/package.json b/package.json
index 281f59fe..0ba06955 100644
--- a/package.json
+++ b/package.json
@@ -40,7 +40,7 @@
     "lint": "eslint . --ext .ts,.tsx && eslint integration-tests",
     "lint:fix": "eslint . --fix && eslint integration-tests --fix",
     "lint:ci": "eslint . --ext .ts,.tsx --max-warnings 0 && eslint integration-tests --max-warnings 0",
-    "format": "prettier --write .",
+    "format": "prettier --experimental-cli --write .",
     "typecheck": "npm run typecheck --workspaces --if-present",
     "preflight": "npm run clean && npm ci && npm run format && npm run lint:ci && npm run build && npm run typecheck && npm run test:ci",
     "prepare": "npm run bundle",

From 4656f17524ce4f580ceb9a9a2599728739d40fdc Mon Sep 17 00:00:00 2001
From: Shreya Keshive <skeshive@gmail.com>
Date: Mon, 11 Aug 2025 15:57:56 -0400
Subject: [PATCH 093/107] Reduce noisy IDE integration error message in
 standalone terminal (#6006)

---
 packages/core/src/ide/ide-client.ts | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/packages/core/src/ide/ide-client.ts b/packages/core/src/ide/ide-client.ts
index 5842a8a8..92224389 100644
--- a/packages/core/src/ide/ide-client.ts
+++ b/packages/core/src/ide/ide-client.ts
@@ -79,8 +79,6 @@ export class IdeClient {
   }
 
   async connect(): Promise<void> {
-    this.setState(IDEConnectionStatus.Connecting);
-
     if (!this.currentIde || !this.currentIdeDisplayName) {
       this.setState(
         IDEConnectionStatus.Disconnected,
@@ -89,11 +87,13 @@ export class IdeClient {
         )
           .map((ide) => getIdeDisplayName(ide))
           .join(', ')}`,
-        true,
+        false,
       );
       return;
     }
 
+    this.setState(IDEConnectionStatus.Connecting);
+
     if (!this.validateWorkspacePath()) {
       return;
     }

From 0e98641b51270f2f63ffb30902b44903d8e88383 Mon Sep 17 00:00:00 2001
From: christine betts <chrstn@uw.edu>
Date: Mon, 11 Aug 2025 21:01:37 +0000
Subject: [PATCH 094/107] Add support for VSCode-like editors (#5699)

Co-authored-by: Jacob Richman <jacob314@gmail.com>
---
 packages/cli/src/ui/App.tsx                 |  3 +-
 packages/cli/src/ui/IdeIntegrationNudge.tsx | 12 ++---
 packages/core/src/ide/detect-ide.ts         | 43 +++++++++++++++--
 packages/core/src/ide/ide-installer.test.ts | 52 ++++++++++++++++++++-
 packages/core/src/ide/ide-installer.ts      | 22 ++++++++-
 5 files changed, 118 insertions(+), 14 deletions(-)

diff --git a/packages/cli/src/ui/App.tsx b/packages/cli/src/ui/App.tsx
index aff3fac3..c4f67294 100644
--- a/packages/cli/src/ui/App.tsx
+++ b/packages/cli/src/ui/App.tsx
@@ -939,8 +939,7 @@ const App = ({ config, settings, startupWarnings = [], version }: AppProps) => {
 
           {shouldShowIdePrompt ? (
             <IdeIntegrationNudge
-              question="Do you want to connect your VS Code editor to Gemini CLI?"
-              description="If you select Yes, we'll install an extension that allows the CLI to access your open files and display diffs directly in VS Code."
+              ideName={config.getIdeClient().getDetectedIdeDisplayName()}
               onComplete={handleIdePromptComplete}
             />
           ) : isFolderTrustDialogOpen ? (
diff --git a/packages/cli/src/ui/IdeIntegrationNudge.tsx b/packages/cli/src/ui/IdeIntegrationNudge.tsx
index 72cd1756..f0c6172d 100644
--- a/packages/cli/src/ui/IdeIntegrationNudge.tsx
+++ b/packages/cli/src/ui/IdeIntegrationNudge.tsx
@@ -13,14 +13,12 @@ import {
 export type IdeIntegrationNudgeResult = 'yes' | 'no' | 'dismiss';
 
 interface IdeIntegrationNudgeProps {
-  question: string;
-  description?: string;
+  ideName?: string;
   onComplete: (result: IdeIntegrationNudgeResult) => void;
 }
 
 export function IdeIntegrationNudge({
-  question,
-  description,
+  ideName,
   onComplete,
 }: IdeIntegrationNudgeProps) {
   useInput((_input, key) => {
@@ -56,9 +54,11 @@ export function IdeIntegrationNudge({
       <Box marginBottom={1} flexDirection="column">
         <Text>
           <Text color="yellow">{'> '}</Text>
-          {question}
+          {`Do you want to connect your ${ideName ?? 'your'} editor to Gemini CLI?`}
         </Text>
-        {description && <Text dimColor>{description}</Text>}
+        <Text
+          dimColor
+        >{`If you select Yes, we'll install an extension that allows the CLI to access your open files and display diffs directly in ${ideName ?? 'your editor'}.`}</Text>
       </Box>
       <RadioButtonSelect
         items={OPTIONS}
diff --git a/packages/core/src/ide/detect-ide.ts b/packages/core/src/ide/detect-ide.ts
index f3d8cc63..759c4103 100644
--- a/packages/core/src/ide/detect-ide.ts
+++ b/packages/core/src/ide/detect-ide.ts
@@ -6,12 +6,33 @@
 
 export enum DetectedIde {
   VSCode = 'vscode',
+  VSCodium = 'vscodium',
+  Cursor = 'cursor',
+  CloudShell = 'cloudshell',
+  Codespaces = 'codespaces',
+  Windsurf = 'windsurf',
+  FirebaseStudio = 'firebasestudio',
+  Trae = 'trae',
 }
 
 export function getIdeDisplayName(ide: DetectedIde): string {
   switch (ide) {
     case DetectedIde.VSCode:
       return 'VS Code';
+    case DetectedIde.VSCodium:
+      return 'VSCodium';
+    case DetectedIde.Cursor:
+      return 'Cursor';
+    case DetectedIde.CloudShell:
+      return 'Cloud Shell';
+    case DetectedIde.Codespaces:
+      return 'GitHub Codespaces';
+    case DetectedIde.Windsurf:
+      return 'Windsurf';
+    case DetectedIde.FirebaseStudio:
+      return 'Firebase Studio';
+    case DetectedIde.Trae:
+      return 'Trae';
     default: {
       // This ensures that if a new IDE is added to the enum, we get a compile-time error.
       const exhaustiveCheck: never = ide;
@@ -21,8 +42,24 @@ export function getIdeDisplayName(ide: DetectedIde): string {
 }
 
 export function detectIde(): DetectedIde | undefined {
-  if (process.env.TERM_PROGRAM === 'vscode') {
-    return DetectedIde.VSCode;
+  // Only VSCode-based integrations are currently supported.
+  if (process.env.TERM_PROGRAM !== 'vscode') {
+    return undefined;
   }
-  return undefined;
+  if (process.env.CURSOR_TRACE_ID) {
+    return DetectedIde.Cursor;
+  }
+  if (process.env.CODESPACES) {
+    return DetectedIde.Codespaces;
+  }
+  if (process.env.EDITOR_IN_CLOUD_SHELL) {
+    return DetectedIde.CloudShell;
+  }
+  if (process.env.TERM_PRODUCT === 'Trae') {
+    return DetectedIde.Trae;
+  }
+  if (process.env.FIREBASE_DEPLOY_AGENT) {
+    return DetectedIde.FirebaseStudio;
+  }
+  return DetectedIde.VSCode;
 }
diff --git a/packages/core/src/ide/ide-installer.test.ts b/packages/core/src/ide/ide-installer.test.ts
index 698c3173..1afd7a36 100644
--- a/packages/core/src/ide/ide-installer.test.ts
+++ b/packages/core/src/ide/ide-installer.test.ts
@@ -24,9 +24,17 @@ describe('ide-installer', () => {
       expect(installer).toBeInstanceOf(Object);
     });
 
-    it('should return null for an unknown IDE', () => {
+    it('should return an OpenVSXInstaller for "vscodium"', () => {
+      const installer = getIdeInstaller(DetectedIde.VSCodium);
+      expect(installer).not.toBeNull();
+      expect(installer).toBeInstanceOf(Object);
+    });
+
+    it('should return a DefaultIDEInstaller for an unknown IDE', () => {
       const installer = getIdeInstaller('unknown' as DetectedIde);
-      expect(installer).toBeNull();
+      // Assuming DefaultIDEInstaller is the fallback
+      expect(installer).not.toBeNull();
+      expect(installer).toBeInstanceOf(Object);
     });
   });
 
@@ -59,4 +67,44 @@ describe('ide-installer', () => {
       });
     });
   });
+
+  describe('OpenVSXInstaller', () => {
+    let installer: IdeInstaller;
+
+    beforeEach(() => {
+      installer = getIdeInstaller(DetectedIde.VSCodium)!;
+    });
+
+    afterEach(() => {
+      vi.restoreAllMocks();
+    });
+
+    describe('install', () => {
+      it('should call execSync with the correct command and return success', async () => {
+        const execSyncSpy = vi
+          .spyOn(child_process, 'execSync')
+          .mockImplementation(() => '');
+        const result = await installer.install();
+        expect(execSyncSpy).toHaveBeenCalledWith(
+          'npx ovsx get google.gemini-cli-vscode-ide-companion',
+          { stdio: 'pipe' },
+        );
+        expect(result.success).toBe(true);
+        expect(result.message).toContain(
+          'VS Code companion extension was installed successfully from OpenVSX',
+        );
+      });
+
+      it('should return a failure message on failed installation', async () => {
+        vi.spyOn(child_process, 'execSync').mockImplementation(() => {
+          throw new Error('Command failed');
+        });
+        const result = await installer.install();
+        expect(result.success).toBe(false);
+        expect(result.message).toContain(
+          'Failed to install VS Code companion extension from OpenVSX',
+        );
+      });
+    });
+  });
 });
diff --git a/packages/core/src/ide/ide-installer.ts b/packages/core/src/ide/ide-installer.ts
index 7db8e2d2..e6192bfa 100644
--- a/packages/core/src/ide/ide-installer.ts
+++ b/packages/core/src/ide/ide-installer.ts
@@ -147,11 +147,31 @@ class VsCodeInstaller implements IdeInstaller {
   }
 }
 
+class OpenVSXInstaller implements IdeInstaller {
+  async install(): Promise<InstallResult> {
+    // TODO: Use the correct extension path.
+    const command = `npx ovsx get google.gemini-cli-vscode-ide-companion`;
+    try {
+      child_process.execSync(command, { stdio: 'pipe' });
+      return {
+        success: true,
+        message:
+          'VS Code companion extension was installed successfully from OpenVSX. Please restart your terminal to complete the setup.',
+      };
+    } catch (_error) {
+      return {
+        success: false,
+        message: `Failed to install VS Code companion extension from OpenVSX. Please try installing it manually.`,
+      };
+    }
+  }
+}
+
 export function getIdeInstaller(ide: DetectedIde): IdeInstaller | null {
   switch (ide) {
     case DetectedIde.VSCode:
       return new VsCodeInstaller();
     default:
-      return null;
+      return new OpenVSXInstaller();
   }
 }

From c0f5f6a5f66be43ebeebb03238ff4ff8fe87a154 Mon Sep 17 00:00:00 2001
From: christine betts <chrstn@uw.edu>
Date: Mon, 11 Aug 2025 21:06:01 +0000
Subject: [PATCH 095/107] [ide-mode] Update handling of workspace paths (#6014)

Co-authored-by: Jacob Richman <jacob314@gmail.com>
---
 .../src/ui/components/messages/ToolConfirmationMessage.tsx | 2 +-
 packages/core/src/ide/ide-client.ts                        | 7 ++++++-
 2 files changed, 7 insertions(+), 2 deletions(-)

diff --git a/packages/cli/src/ui/components/messages/ToolConfirmationMessage.tsx b/packages/cli/src/ui/components/messages/ToolConfirmationMessage.tsx
index b4fe4167..fcdb743f 100644
--- a/packages/cli/src/ui/components/messages/ToolConfirmationMessage.tsx
+++ b/packages/cli/src/ui/components/messages/ToolConfirmationMessage.tsx
@@ -134,7 +134,7 @@ export const ToolConfirmationMessage: React.FC<
     );
     if (config?.getIdeMode() && config?.getIdeModeFeature()) {
       options.push({
-        label: 'No',
+        label: 'No (esc)',
         value: ToolConfirmationOutcome.Cancel,
       });
     } else {
diff --git a/packages/core/src/ide/ide-client.ts b/packages/core/src/ide/ide-client.ts
index 92224389..0ab79e74 100644
--- a/packages/core/src/ide/ide-client.ts
+++ b/packages/core/src/ide/ide-client.ts
@@ -5,6 +5,7 @@
  */
 
 import * as fs from 'node:fs';
+import * as path from 'node:path';
 import {
   detectIde,
   DetectedIde,
@@ -249,7 +250,11 @@ export class IdeClient {
       );
       return false;
     }
-    if (getRealPath(ideWorkspacePath) !== getRealPath(process.cwd())) {
+
+    const idePath = getRealPath(ideWorkspacePath).toLocaleLowerCase();
+    const cwd = getRealPath(process.cwd()).toLocaleLowerCase();
+    const rel = path.relative(idePath, cwd);
+    if (rel.startsWith('..') || path.isAbsolute(rel)) {
       this.setState(
         IDEConnectionStatus.Disconnected,
         `Directory mismatch. Gemini CLI is running in a different location than the open workspace in ${this.currentIdeDisplayName}. Please run the CLI from the same directory as your project's root folder.`,

From 94b619994305895e429d91f47a125682fbf62bc5 Mon Sep 17 00:00:00 2001
From: christine betts <chrstn@uw.edu>
Date: Mon, 11 Aug 2025 21:09:57 +0000
Subject: [PATCH 096/107] [ide-mode] Update sandbox detection logic to support
 macos seatbelt (#6005)

Co-authored-by: matt korwel <matt.korwel@gmail.com>
---
 packages/core/src/ide/ide-client.ts | 5 +----
 1 file changed, 1 insertion(+), 4 deletions(-)

diff --git a/packages/core/src/ide/ide-client.ts b/packages/core/src/ide/ide-client.ts
index 0ab79e74..74d0df74 100644
--- a/packages/core/src/ide/ide-client.ts
+++ b/packages/core/src/ide/ide-client.ts
@@ -365,9 +365,6 @@ export class IdeClient {
 
 function getIdeServerHost() {
   const isInContainer =
-    fs.existsSync('/.dockerenv') ||
-    fs.existsSync('/run/.containerenv') ||
-    !!process.env.SANDBOX ||
-    !!process.env.container;
+    fs.existsSync('/.dockerenv') || fs.existsSync('/run/.containerenv');
   return isInContainer ? 'host.docker.internal' : 'localhost';
 }

From c7fd4c4a962d6e790214e6a0a9cd9b029b85f4e4 Mon Sep 17 00:00:00 2001
From: Shreya Keshive <skeshive@gmail.com>
Date: Mon, 11 Aug 2025 18:09:47 -0400
Subject: [PATCH 097/107] Start IDE connection after config initialization
 (#6018)

---
 packages/cli/src/gemini.tsx        | 8 ++++++++
 packages/core/index.ts             | 5 +++++
 packages/core/src/config/config.ts | 4 ----
 3 files changed, 13 insertions(+), 4 deletions(-)

diff --git a/packages/cli/src/gemini.tsx b/packages/cli/src/gemini.tsx
index cba18047..a0cf352e 100644
--- a/packages/cli/src/gemini.tsx
+++ b/packages/cli/src/gemini.tsx
@@ -34,6 +34,9 @@ import {
   logUserPrompt,
   AuthType,
   getOauthClient,
+  logIdeConnection,
+  IdeConnectionEvent,
+  IdeConnectionType,
 } from '@google/gemini-cli-core';
 import { validateAuthMethod } from './config/auth.js';
 import { setMaxSizedBoxDebugging } from './ui/components/shared/MaxSizedBox.js';
@@ -188,6 +191,11 @@ export async function main() {
 
   await config.initialize();
 
+  if (config.getIdeMode() && config.getIdeModeFeature()) {
+    await config.getIdeClient().connect();
+    logIdeConnection(config, new IdeConnectionEvent(IdeConnectionType.START));
+  }
+
   // Load custom themes from settings
   themeManager.loadCustomThemes(settings.merged.customThemes);
 
diff --git a/packages/core/index.ts b/packages/core/index.ts
index 0c2da4b0..65a214ae 100644
--- a/packages/core/index.ts
+++ b/packages/core/index.ts
@@ -10,3 +10,8 @@ export {
   DEFAULT_GEMINI_FLASH_MODEL,
   DEFAULT_GEMINI_EMBEDDING_MODEL,
 } from './src/config/models.js';
+export { logIdeConnection } from './src/telemetry/loggers.js';
+export {
+  IdeConnectionEvent,
+  IdeConnectionType,
+} from './src/telemetry/types.js';
diff --git a/packages/core/src/config/config.ts b/packages/core/src/config/config.ts
index a06c4505..d02e4153 100644
--- a/packages/core/src/config/config.ts
+++ b/packages/core/src/config/config.ts
@@ -322,10 +322,6 @@ export class Config {
     this.folderTrust = params.folderTrust ?? false;
     this.ideMode = params.ideMode ?? false;
     this.ideClient = IdeClient.getInstance();
-    if (this.ideMode && this.ideModeFeature) {
-      this.ideClient.connect();
-      logIdeConnection(this, new IdeConnectionEvent(IdeConnectionType.START));
-    }
     this.loadMemoryFromIncludeDirectories =
       params.loadMemoryFromIncludeDirectories ?? false;
     this.chatCompression = params.chatCompression;

From f52d073dfbfa4d5091a74bf33ac1c66e51265247 Mon Sep 17 00:00:00 2001
From: Wanlin Du <wanlindu@google.com>
Date: Mon, 11 Aug 2025 16:04:58 -0700
Subject: [PATCH 098/107] chore: migrate from responseSchema to use
 responseJsonSchema. (#4814)

---
 packages/core/src/code_assist/converter.ts    |  5 ++-
 packages/core/src/core/client.test.ts         |  4 +--
 packages/core/src/core/client.ts              |  5 ++-
 .../core/src/services/loopDetectionService.ts |  9 +++---
 packages/core/src/utils/editCorrector.ts      | 31 ++++++++-----------
 packages/core/src/utils/nextSpeakerChecker.ts | 10 +++---
 6 files changed, 28 insertions(+), 36 deletions(-)

diff --git a/packages/core/src/code_assist/converter.ts b/packages/core/src/code_assist/converter.ts
index a71c70da..9c8a2434 100644
--- a/packages/core/src/code_assist/converter.ts
+++ b/packages/core/src/code_assist/converter.ts
@@ -22,7 +22,6 @@ import {
   Part,
   SafetySetting,
   PartUnion,
-  SchemaUnion,
   SpeechConfigUnion,
   ThinkingConfig,
   ToolListUnion,
@@ -61,7 +60,7 @@ interface VertexGenerationConfig {
   frequencyPenalty?: number;
   seed?: number;
   responseMimeType?: string;
-  responseSchema?: SchemaUnion;
+  responseJsonSchema?: unknown;
   routingConfig?: GenerationConfigRoutingConfig;
   modelSelectionConfig?: ModelSelectionConfig;
   responseModalities?: string[];
@@ -230,7 +229,7 @@ function toVertexGenerationConfig(
     frequencyPenalty: config.frequencyPenalty,
     seed: config.seed,
     responseMimeType: config.responseMimeType,
-    responseSchema: config.responseSchema,
+    responseJsonSchema: config.responseJsonSchema,
     routingConfig: config.routingConfig,
     modelSelectionConfig: config.modelSelectionConfig,
     responseModalities: config.responseModalities,
diff --git a/packages/core/src/core/client.test.ts b/packages/core/src/core/client.test.ts
index 2e8d086f..4c6f6dbb 100644
--- a/packages/core/src/core/client.test.ts
+++ b/packages/core/src/core/client.test.ts
@@ -396,7 +396,7 @@ describe('Gemini Client (client.ts)', () => {
             systemInstruction: getCoreSystemPrompt(''),
             temperature: 0,
             topP: 1,
-            responseSchema: schema,
+            responseJsonSchema: schema,
             responseMimeType: 'application/json',
           },
           contents,
@@ -435,7 +435,7 @@ describe('Gemini Client (client.ts)', () => {
             temperature: 0.9,
             topP: 1, // from default
             topK: 20,
-            responseSchema: schema,
+            responseJsonSchema: schema,
             responseMimeType: 'application/json',
           },
           contents,
diff --git a/packages/core/src/core/client.ts b/packages/core/src/core/client.ts
index df3dbc4e..cc492472 100644
--- a/packages/core/src/core/client.ts
+++ b/packages/core/src/core/client.ts
@@ -7,7 +7,6 @@
 import {
   EmbedContentParameters,
   GenerateContentConfig,
-  SchemaUnion,
   PartListUnion,
   Content,
   Tool,
@@ -515,7 +514,7 @@ export class GeminiClient {
 
   async generateJson(
     contents: Content[],
-    schema: SchemaUnion,
+    schema: Record<string, unknown>,
     abortSignal: AbortSignal,
     model?: string,
     config: GenerateContentConfig = {},
@@ -539,7 +538,7 @@ export class GeminiClient {
             config: {
               ...requestConfig,
               systemInstruction,
-              responseSchema: schema,
+              responseJsonSchema: schema,
               responseMimeType: 'application/json',
             },
             contents,
diff --git a/packages/core/src/services/loopDetectionService.ts b/packages/core/src/services/loopDetectionService.ts
index a01e4ee9..409e92a8 100644
--- a/packages/core/src/services/loopDetectionService.ts
+++ b/packages/core/src/services/loopDetectionService.ts
@@ -9,7 +9,6 @@ import { GeminiEventType, ServerGeminiStreamEvent } from '../core/turn.js';
 import { logLoopDetected } from '../telemetry/loggers.js';
 import { LoopDetectedEvent, LoopType } from '../telemetry/types.js';
 import { Config, DEFAULT_GEMINI_FLASH_MODEL } from '../config/config.js';
-import { SchemaUnion, Type } from '@google/genai';
 
 const TOOL_CALL_LOOP_THRESHOLD = 5;
 const CONTENT_LOOP_THRESHOLD = 10;
@@ -341,16 +340,16 @@ Please analyze the conversation history to determine the possibility that the co
       ...recentHistory,
       { role: 'user', parts: [{ text: prompt }] },
     ];
-    const schema: SchemaUnion = {
-      type: Type.OBJECT,
+    const schema: Record<string, unknown> = {
+      type: 'object',
       properties: {
         reasoning: {
-          type: Type.STRING,
+          type: 'string',
           description:
             'Your reasoning on if the conversation is looping without forward progress.',
         },
         confidence: {
-          type: Type.NUMBER,
+          type: 'number',
           description:
             'A number between 0.0 and 1.0 representing your confidence that the conversation is in an unproductive state.',
         },
diff --git a/packages/core/src/utils/editCorrector.ts b/packages/core/src/utils/editCorrector.ts
index 0ef8d4fe..faa52b51 100644
--- a/packages/core/src/utils/editCorrector.ts
+++ b/packages/core/src/utils/editCorrector.ts
@@ -4,12 +4,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import {
-  Content,
-  GenerateContentConfig,
-  SchemaUnion,
-  Type,
-} from '@google/genai';
+import { Content, GenerateContentConfig } from '@google/genai';
 import { GeminiClient } from '../core/client.js';
 import { EditToolParams, EditTool } from '../tools/edit.js';
 import { WriteFileTool } from '../tools/write-file.js';
@@ -364,11 +359,11 @@ export async function ensureCorrectFileContent(
 }
 
 // Define the expected JSON schema for the LLM response for old_string correction
-const OLD_STRING_CORRECTION_SCHEMA: SchemaUnion = {
-  type: Type.OBJECT,
+const OLD_STRING_CORRECTION_SCHEMA: Record<string, unknown> = {
+  type: 'object',
   properties: {
     corrected_target_snippet: {
-      type: Type.STRING,
+      type: 'string',
       description:
         'The corrected version of the target snippet that exactly and uniquely matches a segment within the provided file content.',
     },
@@ -438,11 +433,11 @@ Return ONLY the corrected target snippet in the specified JSON format with the k
 }
 
 // Define the expected JSON schema for the new_string correction LLM response
-const NEW_STRING_CORRECTION_SCHEMA: SchemaUnion = {
-  type: Type.OBJECT,
+const NEW_STRING_CORRECTION_SCHEMA: Record<string, unknown> = {
+  type: 'object',
   properties: {
     corrected_new_string: {
-      type: Type.STRING,
+      type: 'string',
       description:
         'The original_new_string adjusted to be a suitable replacement for the corrected_old_string, while maintaining the original intent of the change.',
     },
@@ -521,11 +516,11 @@ Return ONLY the corrected string in the specified JSON format with the key 'corr
   }
 }
 
-const CORRECT_NEW_STRING_ESCAPING_SCHEMA: SchemaUnion = {
-  type: Type.OBJECT,
+const CORRECT_NEW_STRING_ESCAPING_SCHEMA: Record<string, unknown> = {
+  type: 'object',
   properties: {
     corrected_new_string_escaping: {
-      type: Type.STRING,
+      type: 'string',
       description:
         'The new_string with corrected escaping, ensuring it is a proper replacement for the old_string, especially considering potential over-escaping issues from previous LLM generations.',
     },
@@ -593,11 +588,11 @@ Return ONLY the corrected string in the specified JSON format with the key 'corr
   }
 }
 
-const CORRECT_STRING_ESCAPING_SCHEMA: SchemaUnion = {
-  type: Type.OBJECT,
+const CORRECT_STRING_ESCAPING_SCHEMA: Record<string, unknown> = {
+  type: 'object',
   properties: {
     corrected_string_escaping: {
-      type: Type.STRING,
+      type: 'string',
       description:
         'The string with corrected escaping, ensuring it is valid, specially considering potential over-escaping issues from previous LLM generations.',
     },
diff --git a/packages/core/src/utils/nextSpeakerChecker.ts b/packages/core/src/utils/nextSpeakerChecker.ts
index 8497db61..4ae8f437 100644
--- a/packages/core/src/utils/nextSpeakerChecker.ts
+++ b/packages/core/src/utils/nextSpeakerChecker.ts
@@ -4,7 +4,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import { Content, SchemaUnion, Type } from '@google/genai';
+import { Content } from '@google/genai';
 import { DEFAULT_GEMINI_FLASH_MODEL } from '../config/models.js';
 import { GeminiClient } from '../core/client.js';
 import { GeminiChat } from '../core/geminiChat.js';
@@ -16,16 +16,16 @@ const CHECK_PROMPT = `Analyze *only* the content and structure of your immediate
 2.  **Question to User:** If your last response ends with a direct question specifically addressed *to the user*, then the **'user'** should speak next.
 3.  **Waiting for User:** If your last response completed a thought, statement, or task *and* does not meet the criteria for Rule 1 (Model Continues) or Rule 2 (Question to User), it implies a pause expecting user input or reaction. In this case, the **'user'** should speak next.`;
 
-const RESPONSE_SCHEMA: SchemaUnion = {
-  type: Type.OBJECT,
+const RESPONSE_SCHEMA: Record<string, unknown> = {
+  type: 'object',
   properties: {
     reasoning: {
-      type: Type.STRING,
+      type: 'string',
       description:
         "Brief explanation justifying the 'next_speaker' choice based *strictly* on the applicable rule and the content/structure of the preceding turn.",
     },
     next_speaker: {
-      type: Type.STRING,
+      type: 'string',
       enum: ['user', 'model'],
       description:
         'Who should speak next based *only* on the preceding turn and the decision rules',

From d9fb08c9da3d2e8c501ec9badb2e2bd79eb15b93 Mon Sep 17 00:00:00 2001
From: Wanlin Du <wanlindu@google.com>
Date: Mon, 11 Aug 2025 16:12:41 -0700
Subject: [PATCH 099/107] feat: migrate tools to use parametersJsonSchema.
 (#5330)

---
 packages/core/src/tools/edit.ts               |  16 +-
 packages/core/src/tools/glob.ts               |  16 +-
 packages/core/src/tools/grep.ts               |  14 +-
 packages/core/src/tools/ls.ts                 |  20 +-
 packages/core/src/tools/mcp-tool.ts           |  26 +-
 packages/core/src/tools/memoryTool.test.ts    |  12 +-
 packages/core/src/tools/memoryTool.ts         |  10 +-
 packages/core/src/tools/read-file.ts          |  15 +-
 packages/core/src/tools/read-many-files.ts    |  41 ++--
 packages/core/src/tools/shell.ts              |  14 +-
 packages/core/src/tools/tool-registry.test.ts | 222 ++----------------
 packages/core/src/tools/tool-registry.ts      |  84 +------
 packages/core/src/tools/tools.ts              |  10 +-
 packages/core/src/tools/web-fetch.ts          |  10 +-
 packages/core/src/tools/web-search.ts         |   5 +-
 packages/core/src/tools/write-file.ts         |  12 +-
 packages/core/src/utils/schemaValidator.ts    |  37 +--
 17 files changed, 141 insertions(+), 423 deletions(-)

diff --git a/packages/core/src/tools/edit.ts b/packages/core/src/tools/edit.ts
index 33323203..86641300 100644
--- a/packages/core/src/tools/edit.ts
+++ b/packages/core/src/tools/edit.ts
@@ -19,7 +19,6 @@ import {
   ToolResultDisplay,
 } from './tools.js';
 import { ToolErrorType } from './tool-error.js';
-import { Type } from '@google/genai';
 import { SchemaValidator } from '../utils/schemaValidator.js';
 import { makeRelative, shortenPath } from '../utils/paths.js';
 import { isNodeError } from '../utils/errors.js';
@@ -443,27 +442,27 @@ Expectation for required parameters:
           file_path: {
             description:
               "The absolute path to the file to modify. Must start with '/'.",
-            type: Type.STRING,
+            type: 'string',
           },
           old_string: {
             description:
               'The exact literal text to replace, preferably unescaped. For single replacements (default), include at least 3 lines of context BEFORE and AFTER the target text, matching whitespace and indentation precisely. For multiple replacements, specify expected_replacements parameter. If this string is not the exact literal text (i.e. you escaped it) or does not match exactly, the tool will fail.',
-            type: Type.STRING,
+            type: 'string',
           },
           new_string: {
             description:
               'The exact literal text to replace `old_string` with, preferably unescaped. Provide the EXACT text. Ensure the resulting code is correct and idiomatic.',
-            type: Type.STRING,
+            type: 'string',
           },
           expected_replacements: {
-            type: Type.NUMBER,
+            type: 'number',
             description:
               'Number of replacements expected. Defaults to 1 if not specified. Use when you want to replace multiple occurrences.',
             minimum: 1,
           },
         },
         required: ['file_path', 'old_string', 'new_string'],
-        type: Type.OBJECT,
+        type: 'object',
       },
     );
   }
@@ -474,7 +473,10 @@ Expectation for required parameters:
    * @returns Error message string or null if valid
    */
   validateToolParams(params: EditToolParams): string | null {
-    const errors = SchemaValidator.validate(this.schema.parameters, params);
+    const errors = SchemaValidator.validate(
+      this.schema.parametersJsonSchema,
+      params,
+    );
     if (errors) {
       return errors;
     }
diff --git a/packages/core/src/tools/glob.ts b/packages/core/src/tools/glob.ts
index df0cc348..eaedc20f 100644
--- a/packages/core/src/tools/glob.ts
+++ b/packages/core/src/tools/glob.ts
@@ -15,7 +15,6 @@ import {
   ToolInvocation,
   ToolResult,
 } from './tools.js';
-import { Type } from '@google/genai';
 import { shortenPath, makeRelative } from '../utils/paths.js';
 import { Config } from '../config/config.js';
 
@@ -255,26 +254,26 @@ export class GlobTool extends BaseDeclarativeTool<GlobToolParams, ToolResult> {
           pattern: {
             description:
               "The glob pattern to match against (e.g., '**/*.py', 'docs/*.md').",
-            type: Type.STRING,
+            type: 'string',
           },
           path: {
             description:
               'Optional: The absolute path to the directory to search within. If omitted, searches the root directory.',
-            type: Type.STRING,
+            type: 'string',
           },
           case_sensitive: {
             description:
               'Optional: Whether the search should be case-sensitive. Defaults to false.',
-            type: Type.BOOLEAN,
+            type: 'boolean',
           },
           respect_git_ignore: {
             description:
               'Optional: Whether to respect .gitignore patterns when finding files. Only available in git repositories. Defaults to true.',
-            type: Type.BOOLEAN,
+            type: 'boolean',
           },
         },
         required: ['pattern'],
-        type: Type.OBJECT,
+        type: 'object',
       },
     );
   }
@@ -283,7 +282,10 @@ export class GlobTool extends BaseDeclarativeTool<GlobToolParams, ToolResult> {
    * Validates the parameters for the tool.
    */
   validateToolParams(params: GlobToolParams): string | null {
-    const errors = SchemaValidator.validate(this.schema.parameters, params);
+    const errors = SchemaValidator.validate(
+      this.schema.parametersJsonSchema,
+      params,
+    );
     if (errors) {
       return errors;
     }
diff --git a/packages/core/src/tools/grep.ts b/packages/core/src/tools/grep.ts
index 8e2b84f1..f8ecdc9c 100644
--- a/packages/core/src/tools/grep.ts
+++ b/packages/core/src/tools/grep.ts
@@ -17,7 +17,6 @@ import {
   ToolInvocation,
   ToolResult,
 } from './tools.js';
-import { Type } from '@google/genai';
 import { SchemaValidator } from '../utils/schemaValidator.js';
 import { makeRelative, shortenPath } from '../utils/paths.js';
 import { getErrorMessage, isNodeError } from '../utils/errors.js';
@@ -550,21 +549,21 @@ export class GrepTool extends BaseDeclarativeTool<GrepToolParams, ToolResult> {
           pattern: {
             description:
               "The regular expression (regex) pattern to search for within file contents (e.g., 'function\\s+myFunction', 'import\\s+\\{.*\\}\\s+from\\s+.*').",
-            type: Type.STRING,
+            type: 'string',
           },
           path: {
             description:
               'Optional: The absolute path to the directory to search within. If omitted, searches the current working directory.',
-            type: Type.STRING,
+            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: Type.STRING,
+            type: 'string',
           },
         },
         required: ['pattern'],
-        type: Type.OBJECT,
+        type: 'object',
       },
     );
   }
@@ -616,7 +615,10 @@ export class GrepTool extends BaseDeclarativeTool<GrepToolParams, ToolResult> {
    * @returns An error message string if invalid, null otherwise
    */
   validateToolParams(params: GrepToolParams): string | null {
-    const errors = SchemaValidator.validate(this.schema.parameters, params);
+    const errors = SchemaValidator.validate(
+      this.schema.parametersJsonSchema,
+      params,
+    );
     if (errors) {
       return errors;
     }
diff --git a/packages/core/src/tools/ls.ts b/packages/core/src/tools/ls.ts
index 8490f18a..79820246 100644
--- a/packages/core/src/tools/ls.ts
+++ b/packages/core/src/tools/ls.ts
@@ -7,7 +7,6 @@
 import fs from 'fs';
 import path from 'path';
 import { BaseTool, Icon, ToolResult } from './tools.js';
-import { Type } from '@google/genai';
 import { SchemaValidator } from '../utils/schemaValidator.js';
 import { makeRelative, shortenPath } from '../utils/paths.js';
 import { Config, DEFAULT_FILE_FILTERING_OPTIONS } from '../config/config.js';
@@ -82,35 +81,35 @@ export class LSTool extends BaseTool<LSToolParams, ToolResult> {
           path: {
             description:
               'The absolute path to the directory to list (must be absolute, not relative)',
-            type: Type.STRING,
+            type: 'string',
           },
           ignore: {
             description: 'List of glob patterns to ignore',
             items: {
-              type: Type.STRING,
+              type: 'string',
             },
-            type: Type.ARRAY,
+            type: 'array',
           },
           file_filtering_options: {
             description:
               'Optional: Whether to respect ignore patterns from .gitignore or .geminiignore',
-            type: Type.OBJECT,
+            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: Type.BOOLEAN,
+                type: 'boolean',
               },
               respect_gemini_ignore: {
                 description:
                   'Optional: Whether to respect .geminiignore patterns when listing files. Defaults to true.',
-                type: Type.BOOLEAN,
+                type: 'boolean',
               },
             },
           },
         },
         required: ['path'],
-        type: Type.OBJECT,
+        type: 'object',
       },
     );
   }
@@ -121,7 +120,10 @@ export class LSTool extends BaseTool<LSToolParams, ToolResult> {
    * @returns An error message string if invalid, null otherwise
    */
   validateToolParams(params: LSToolParams): string | null {
-    const errors = SchemaValidator.validate(this.schema.parameters, params);
+    const errors = SchemaValidator.validate(
+      this.schema.parametersJsonSchema,
+      params,
+    );
     if (errors) {
       return errors;
     }
diff --git a/packages/core/src/tools/mcp-tool.ts b/packages/core/src/tools/mcp-tool.ts
index 3dd62e2b..4b9a9818 100644
--- a/packages/core/src/tools/mcp-tool.ts
+++ b/packages/core/src/tools/mcp-tool.ts
@@ -12,13 +12,7 @@ import {
   ToolMcpConfirmationDetails,
   Icon,
 } from './tools.js';
-import {
-  CallableTool,
-  Part,
-  FunctionCall,
-  FunctionDeclaration,
-  Type,
-} from '@google/genai';
+import { CallableTool, Part, FunctionCall } from '@google/genai';
 
 type ToolParams = Record<string, unknown>;
 
@@ -64,7 +58,7 @@ export class DiscoveredMCPTool extends BaseTool<ToolParams, ToolResult> {
     readonly serverName: string,
     readonly serverToolName: string,
     description: string,
-    readonly parameterSchemaJson: unknown,
+    readonly parameterSchema: unknown,
     readonly timeout?: number,
     readonly trust?: boolean,
     nameOverride?: string,
@@ -74,7 +68,7 @@ export class DiscoveredMCPTool extends BaseTool<ToolParams, ToolResult> {
       `${serverToolName} (${serverName} MCP Server)`,
       description,
       Icon.Hammer,
-      { type: Type.OBJECT }, // this is a dummy Schema for MCP, will be not be used to construct the FunctionDeclaration
+      parameterSchema,
       true, // isOutputMarkdown
       false, // canUpdateOutput
     );
@@ -86,25 +80,13 @@ export class DiscoveredMCPTool extends BaseTool<ToolParams, ToolResult> {
       this.serverName,
       this.serverToolName,
       this.description,
-      this.parameterSchemaJson,
+      this.parameterSchema,
       this.timeout,
       this.trust,
       `${this.serverName}__${this.serverToolName}`,
     );
   }
 
-  /**
-   * Overrides the base schema to use parametersJsonSchema when building
-   * FunctionDeclaration
-   */
-  override get schema(): FunctionDeclaration {
-    return {
-      name: this.name,
-      description: this.description,
-      parametersJsonSchema: this.parameterSchemaJson,
-    };
-  }
-
   async shouldConfirmExecute(
     _params: ToolParams,
     _abortSignal: AbortSignal,
diff --git a/packages/core/src/tools/memoryTool.test.ts b/packages/core/src/tools/memoryTool.test.ts
index 5a9b5f26..2a5c4c39 100644
--- a/packages/core/src/tools/memoryTool.test.ts
+++ b/packages/core/src/tools/memoryTool.test.ts
@@ -203,7 +203,17 @@ describe('MemoryTool', () => {
       );
       expect(memoryTool.schema).toBeDefined();
       expect(memoryTool.schema.name).toBe('save_memory');
-      expect(memoryTool.schema.parameters?.properties?.fact).toBeDefined();
+      expect(memoryTool.schema.parametersJsonSchema).toStrictEqual({
+        type: 'object',
+        properties: {
+          fact: {
+            type: 'string',
+            description:
+              'The specific fact or piece of information to remember. Should be a clear, self-contained statement.',
+          },
+        },
+        required: ['fact'],
+      });
     });
 
     it('should call performAddMemoryEntry with correct parameters and return success', async () => {
diff --git a/packages/core/src/tools/memoryTool.ts b/packages/core/src/tools/memoryTool.ts
index f3bf315b..f0c95b6a 100644
--- a/packages/core/src/tools/memoryTool.ts
+++ b/packages/core/src/tools/memoryTool.ts
@@ -11,7 +11,7 @@ import {
   ToolConfirmationOutcome,
   Icon,
 } from './tools.js';
-import { FunctionDeclaration, Type } from '@google/genai';
+import { FunctionDeclaration } from '@google/genai';
 import * as fs from 'fs/promises';
 import * as path from 'path';
 import { homedir } from 'os';
@@ -24,11 +24,11 @@ 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.',
-  parameters: {
-    type: Type.OBJECT,
+  parametersJsonSchema: {
+    type: 'object',
     properties: {
       fact: {
-        type: Type.STRING,
+        type: 'string',
         description:
           'The specific fact or piece of information to remember. Should be a clear, self-contained statement.',
       },
@@ -123,7 +123,7 @@ export class MemoryTool
       'Save Memory',
       memoryToolDescription,
       Icon.LightBulb,
-      memoryToolSchemaData.parameters as Record<string, unknown>,
+      memoryToolSchemaData.parametersJsonSchema as Record<string, unknown>,
     );
   }
 
diff --git a/packages/core/src/tools/read-file.ts b/packages/core/src/tools/read-file.ts
index 2ab50282..0c040b66 100644
--- a/packages/core/src/tools/read-file.ts
+++ b/packages/core/src/tools/read-file.ts
@@ -16,7 +16,7 @@ import {
   ToolResult,
 } from './tools.js';
 import { ToolErrorType } from './tool-error.js';
-import { PartUnion, Type } from '@google/genai';
+import { PartUnion } from '@google/genai';
 import {
   processSingleFileContent,
   getSpecificMimeType,
@@ -179,27 +179,30 @@ export class ReadFileTool extends BaseDeclarativeTool<
           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: Type.STRING,
+            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: Type.NUMBER,
+            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: Type.NUMBER,
+            type: 'number',
           },
         },
         required: ['absolute_path'],
-        type: Type.OBJECT,
+        type: 'object',
       },
     );
   }
 
   protected validateToolParams(params: ReadFileToolParams): string | null {
-    const errors = SchemaValidator.validate(this.schema.parameters, params);
+    const errors = SchemaValidator.validate(
+      this.schema.parametersJsonSchema,
+      params,
+    );
     if (errors) {
       return errors;
     }
diff --git a/packages/core/src/tools/read-many-files.ts b/packages/core/src/tools/read-many-files.ts
index a380ea91..1c92b4f3 100644
--- a/packages/core/src/tools/read-many-files.ts
+++ b/packages/core/src/tools/read-many-files.ts
@@ -16,7 +16,7 @@ import {
   DEFAULT_ENCODING,
   getSpecificMimeType,
 } from '../utils/fileUtils.js';
-import { PartListUnion, Schema, Type } from '@google/genai';
+import { PartListUnion } from '@google/genai';
 import { Config, DEFAULT_FILE_FILTERING_OPTIONS } from '../config/config.js';
 import {
   recordFileOperationMetric,
@@ -150,47 +150,47 @@ export class ReadManyFilesTool extends BaseTool<
   static readonly Name: string = 'read_many_files';
 
   constructor(private config: Config) {
-    const parameterSchema: Schema = {
-      type: Type.OBJECT,
+    const parameterSchema = {
+      type: 'object',
       properties: {
         paths: {
-          type: Type.ARRAY,
+          type: 'array',
           items: {
-            type: Type.STRING,
-            minLength: '1',
+            type: 'string',
+            minLength: 1,
           },
-          minItems: '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: Type.ARRAY,
+          type: 'array',
           items: {
-            type: Type.STRING,
-            minLength: '1',
+            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: Type.ARRAY,
+          type: 'array',
           items: {
-            type: Type.STRING,
-            minLength: '1',
+            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: Type.BOOLEAN,
+          type: 'boolean',
           description:
             'Optional. Whether to search recursively (primarily controlled by `**` in glob patterns). Defaults to true.',
           default: true,
         },
         useDefaultExcludes: {
-          type: Type.BOOLEAN,
+          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,
@@ -198,17 +198,17 @@ export class ReadManyFilesTool extends BaseTool<
         file_filtering_options: {
           description:
             'Whether to respect ignore patterns from .gitignore or .geminiignore',
-          type: Type.OBJECT,
+          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: Type.BOOLEAN,
+              type: 'boolean',
             },
             respect_gemini_ignore: {
               description:
                 'Optional: Whether to respect .geminiignore patterns when listing files. Defaults to true.',
-              type: Type.BOOLEAN,
+              type: 'boolean',
             },
           },
         },
@@ -235,7 +235,10 @@ Use this tool when the user's query implies needing the content of several files
   }
 
   validateParams(params: ReadManyFilesParams): string | null {
-    const errors = SchemaValidator.validate(this.schema.parameters, params);
+    const errors = SchemaValidator.validate(
+      this.schema.parametersJsonSchema,
+      params,
+    );
     if (errors) {
       return errors;
     }
diff --git a/packages/core/src/tools/shell.ts b/packages/core/src/tools/shell.ts
index 6106c0cd..de9b7c2f 100644
--- a/packages/core/src/tools/shell.ts
+++ b/packages/core/src/tools/shell.ts
@@ -18,7 +18,6 @@ import {
   Icon,
 } from './tools.js';
 import { ToolErrorType } from './tool-error.js';
-import { Type } from '@google/genai';
 import { SchemaValidator } from '../utils/schemaValidator.js';
 import { getErrorMessage } from '../utils/errors.js';
 import { summarizeToolOutput } from '../utils/summarizer.js';
@@ -64,19 +63,19 @@ export class ShellTool extends BaseTool<ShellToolParams, ToolResult> {
       Process Group PGID: Process group started or \`(none)\``,
       Icon.Terminal,
       {
-        type: Type.OBJECT,
+        type: 'object',
         properties: {
           command: {
-            type: Type.STRING,
+            type: 'string',
             description: 'Exact bash command to execute as `bash -c <command>`',
           },
           description: {
-            type: Type.STRING,
+            type: 'string',
             description:
               'Brief description of the command for the user. Be specific and concise. Ideally a single sentence. Can be up to 3 sentences for clarity. No line breaks.',
           },
           directory: {
-            type: Type.STRING,
+            type: 'string',
             description:
               '(OPTIONAL) Directory to run the command in, if not the project root directory. Must be relative to the project root directory and must already exist.',
           },
@@ -113,7 +112,10 @@ export class ShellTool extends BaseTool<ShellToolParams, ToolResult> {
       }
       return commandCheck.reason;
     }
-    const errors = SchemaValidator.validate(this.schema.parameters, params);
+    const errors = SchemaValidator.validate(
+      this.schema.parametersJsonSchema,
+      params,
+    );
     if (errors) {
       return errors;
     }
diff --git a/packages/core/src/tools/tool-registry.test.ts b/packages/core/src/tools/tool-registry.test.ts
index d8e536b7..13dff08c 100644
--- a/packages/core/src/tools/tool-registry.test.ts
+++ b/packages/core/src/tools/tool-registry.test.ts
@@ -15,19 +15,9 @@ import {
   Mocked,
 } from 'vitest';
 import { Config, ConfigParameters, ApprovalMode } from '../config/config.js';
-import {
-  ToolRegistry,
-  DiscoveredTool,
-  sanitizeParameters,
-} from './tool-registry.js';
+import { ToolRegistry, DiscoveredTool } from './tool-registry.js';
 import { DiscoveredMCPTool } from './mcp-tool.js';
-import {
-  FunctionDeclaration,
-  CallableTool,
-  mcpToTool,
-  Type,
-  Schema,
-} from '@google/genai';
+import { FunctionDeclaration, CallableTool, mcpToTool } from '@google/genai';
 import { spawn } from 'node:child_process';
 
 import fs from 'node:fs';
@@ -254,18 +244,18 @@ describe('ToolRegistry', () => {
   });
 
   describe('discoverTools', () => {
-    it('should sanitize tool parameters during discovery from command', async () => {
+    it('should will preserve tool parametersJsonSchema during discovery from command', async () => {
       const discoveryCommand = 'my-discovery-command';
       mockConfigGetToolDiscoveryCommand.mockReturnValue(discoveryCommand);
 
       const unsanitizedToolDeclaration: FunctionDeclaration = {
         name: 'tool-with-bad-format',
         description: 'A tool with an invalid format property',
-        parameters: {
-          type: Type.OBJECT,
+        parametersJsonSchema: {
+          type: 'object',
           properties: {
             some_string: {
-              type: Type.STRING,
+              type: 'string',
               format: 'uuid', // This is an unsupported format
             },
           },
@@ -308,12 +298,16 @@ describe('ToolRegistry', () => {
       expect(discoveredTool).toBeDefined();
 
       const registeredParams = (discoveredTool as DiscoveredTool).schema
-        .parameters as Schema;
-      expect(registeredParams.properties?.['some_string']).toBeDefined();
-      expect(registeredParams.properties?.['some_string']).toHaveProperty(
-        'format',
-        undefined,
-      );
+        .parametersJsonSchema;
+      expect(registeredParams).toStrictEqual({
+        type: 'object',
+        properties: {
+          some_string: {
+            type: 'string',
+            format: 'uuid',
+          },
+        },
+      });
     });
 
     it('should discover tools using MCP servers defined in getMcpServers', async () => {
@@ -365,187 +359,3 @@ describe('ToolRegistry', () => {
     });
   });
 });
-
-describe('sanitizeParameters', () => {
-  it('should remove default when anyOf is present', () => {
-    const schema: Schema = {
-      anyOf: [{ type: Type.STRING }, { type: Type.NUMBER }],
-      default: 'hello',
-    };
-    sanitizeParameters(schema);
-    expect(schema.default).toBeUndefined();
-  });
-
-  it('should recursively sanitize items in anyOf', () => {
-    const schema: Schema = {
-      anyOf: [
-        {
-          anyOf: [{ type: Type.STRING }],
-          default: 'world',
-        },
-        { type: Type.NUMBER },
-      ],
-    };
-    sanitizeParameters(schema);
-    expect(schema.anyOf![0].default).toBeUndefined();
-  });
-
-  it('should recursively sanitize items in items', () => {
-    const schema: Schema = {
-      items: {
-        anyOf: [{ type: Type.STRING }],
-        default: 'world',
-      },
-    };
-    sanitizeParameters(schema);
-    expect(schema.items!.default).toBeUndefined();
-  });
-
-  it('should recursively sanitize items in properties', () => {
-    const schema: Schema = {
-      properties: {
-        prop1: {
-          anyOf: [{ type: Type.STRING }],
-          default: 'world',
-        },
-      },
-    };
-    sanitizeParameters(schema);
-    expect(schema.properties!.prop1.default).toBeUndefined();
-  });
-
-  it('should handle complex nested schemas', () => {
-    const schema: Schema = {
-      properties: {
-        prop1: {
-          items: {
-            anyOf: [{ type: Type.STRING }],
-            default: 'world',
-          },
-        },
-        prop2: {
-          anyOf: [
-            {
-              properties: {
-                nestedProp: {
-                  anyOf: [{ type: Type.NUMBER }],
-                  default: 123,
-                },
-              },
-            },
-          ],
-        },
-      },
-    };
-    sanitizeParameters(schema);
-    expect(schema.properties!.prop1.items!.default).toBeUndefined();
-    const nestedProp =
-      schema.properties!.prop2.anyOf![0].properties!.nestedProp;
-    expect(nestedProp?.default).toBeUndefined();
-  });
-
-  it('should remove unsupported format from a simple string property', () => {
-    const schema: Schema = {
-      type: Type.OBJECT,
-      properties: {
-        name: { type: Type.STRING },
-        id: { type: Type.STRING, format: 'uuid' },
-      },
-    };
-    sanitizeParameters(schema);
-    expect(schema.properties?.['id']).toHaveProperty('format', undefined);
-    expect(schema.properties?.['name']).not.toHaveProperty('format');
-  });
-
-  it('should NOT remove supported format values', () => {
-    const schema: Schema = {
-      type: Type.OBJECT,
-      properties: {
-        date: { type: Type.STRING, format: 'date-time' },
-        role: {
-          type: Type.STRING,
-          format: 'enum',
-          enum: ['admin', 'user'],
-        },
-      },
-    };
-    const originalSchema = JSON.parse(JSON.stringify(schema));
-    sanitizeParameters(schema);
-    expect(schema).toEqual(originalSchema);
-  });
-
-  it('should handle arrays of objects', () => {
-    const schema: Schema = {
-      type: Type.OBJECT,
-      properties: {
-        items: {
-          type: Type.ARRAY,
-          items: {
-            type: Type.OBJECT,
-            properties: {
-              itemId: { type: Type.STRING, format: 'uuid' },
-            },
-          },
-        },
-      },
-    };
-    sanitizeParameters(schema);
-    expect(
-      (schema.properties?.['items']?.items as Schema)?.properties?.['itemId'],
-    ).toHaveProperty('format', undefined);
-  });
-
-  it('should handle schemas with no properties to sanitize', () => {
-    const schema: Schema = {
-      type: Type.OBJECT,
-      properties: {
-        count: { type: Type.NUMBER },
-        isActive: { type: Type.BOOLEAN },
-      },
-    };
-    const originalSchema = JSON.parse(JSON.stringify(schema));
-    sanitizeParameters(schema);
-    expect(schema).toEqual(originalSchema);
-  });
-
-  it('should not crash on an empty or undefined schema', () => {
-    expect(() => sanitizeParameters({})).not.toThrow();
-    expect(() => sanitizeParameters(undefined)).not.toThrow();
-  });
-
-  it('should handle complex nested schemas with cycles', () => {
-    const userNode: any = {
-      type: Type.OBJECT,
-      properties: {
-        id: { type: Type.STRING, format: 'uuid' },
-        name: { type: Type.STRING },
-        manager: {
-          type: Type.OBJECT,
-          properties: {
-            id: { type: Type.STRING, format: 'uuid' },
-          },
-        },
-      },
-    };
-    userNode.properties.reports = {
-      type: Type.ARRAY,
-      items: userNode,
-    };
-
-    const schema: Schema = {
-      type: Type.OBJECT,
-      properties: {
-        ceo: userNode,
-      },
-    };
-
-    expect(() => sanitizeParameters(schema)).not.toThrow();
-    expect(schema.properties?.['ceo']?.properties?.['id']).toHaveProperty(
-      'format',
-      undefined,
-    );
-    expect(
-      schema.properties?.['ceo']?.properties?.['manager']?.properties?.['id'],
-    ).toHaveProperty('format', undefined);
-  });
-});
diff --git a/packages/core/src/tools/tool-registry.ts b/packages/core/src/tools/tool-registry.ts
index 70226052..17d324b3 100644
--- a/packages/core/src/tools/tool-registry.ts
+++ b/packages/core/src/tools/tool-registry.ts
@@ -4,7 +4,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import { FunctionDeclaration, Schema, Type } from '@google/genai';
+import { FunctionDeclaration } from '@google/genai';
 import { AnyDeclarativeTool, Icon, ToolResult, BaseTool } from './tools.js';
 import { Config } from '../config/config.js';
 import { spawn } from 'node:child_process';
@@ -331,14 +331,12 @@ export class ToolRegistry {
           console.warn('Discovered a tool with no name. Skipping.');
           continue;
         }
-        // Sanitize the parameters before registering the tool.
         const parameters =
-          func.parameters &&
-          typeof func.parameters === 'object' &&
-          !Array.isArray(func.parameters)
-            ? (func.parameters as Schema)
+          func.parametersJsonSchema &&
+          typeof func.parametersJsonSchema === 'object' &&
+          !Array.isArray(func.parametersJsonSchema)
+            ? func.parametersJsonSchema
             : {};
-        sanitizeParameters(parameters);
         this.registerTool(
           new DiscoveredTool(
             this.config,
@@ -413,75 +411,3 @@ export class ToolRegistry {
     return this.tools.get(name);
   }
 }
-
-/**
- * Sanitizes a schema object in-place to ensure compatibility with the Gemini API.
- *
- * NOTE: This function mutates the passed schema object.
- *
- * It performs the following actions:
- * - Removes the `default` property when `anyOf` is present.
- * - Removes unsupported `format` values from string properties, keeping only 'enum' and 'date-time'.
- * - Recursively sanitizes nested schemas within `anyOf`, `items`, and `properties`.
- * - Handles circular references within the schema to prevent infinite loops.
- *
- * @param schema The schema object to sanitize. It will be modified directly.
- */
-export function sanitizeParameters(schema?: Schema) {
-  _sanitizeParameters(schema, new Set<Schema>());
-}
-
-/**
- * Internal recursive implementation for sanitizeParameters.
- * @param schema The schema object to sanitize.
- * @param visited A set used to track visited schema objects during recursion.
- */
-function _sanitizeParameters(schema: Schema | undefined, visited: Set<Schema>) {
-  if (!schema || visited.has(schema)) {
-    return;
-  }
-  visited.add(schema);
-
-  if (schema.anyOf) {
-    // Vertex AI gets confused if both anyOf and default are set.
-    schema.default = undefined;
-    for (const item of schema.anyOf) {
-      if (typeof item !== 'boolean') {
-        _sanitizeParameters(item, visited);
-      }
-    }
-  }
-  if (schema.items && typeof schema.items !== 'boolean') {
-    _sanitizeParameters(schema.items, visited);
-  }
-  if (schema.properties) {
-    for (const item of Object.values(schema.properties)) {
-      if (typeof item !== 'boolean') {
-        _sanitizeParameters(item, visited);
-      }
-    }
-  }
-
-  // Handle enum values - Gemini API only allows enum for STRING type
-  if (schema.enum && Array.isArray(schema.enum)) {
-    if (schema.type !== Type.STRING) {
-      // If enum is present but type is not STRING, convert type to STRING
-      schema.type = Type.STRING;
-    }
-    // Filter out null and undefined values, then convert remaining values to strings for Gemini API compatibility
-    schema.enum = schema.enum
-      .filter((value: unknown) => value !== null && value !== undefined)
-      .map((value: unknown) => String(value));
-  }
-
-  // Vertex AI only supports 'enum' and 'date-time' for STRING format.
-  if (schema.type === Type.STRING) {
-    if (
-      schema.format &&
-      schema.format !== 'enum' &&
-      schema.format !== 'date-time'
-    ) {
-      schema.format = undefined;
-    }
-  }
-}
diff --git a/packages/core/src/tools/tools.ts b/packages/core/src/tools/tools.ts
index 8e064973..4b13174c 100644
--- a/packages/core/src/tools/tools.ts
+++ b/packages/core/src/tools/tools.ts
@@ -4,7 +4,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import { FunctionDeclaration, PartListUnion, Schema } from '@google/genai';
+import { FunctionDeclaration, PartListUnion } from '@google/genai';
 import { ToolErrorType } from './tool-error.js';
 import { DiffUpdateResult } from '../ide/ideContext.js';
 
@@ -186,7 +186,7 @@ export abstract class DeclarativeTool<
     readonly displayName: string,
     readonly description: string,
     readonly icon: Icon,
-    readonly parameterSchema: Schema,
+    readonly parameterSchema: unknown,
     readonly isOutputMarkdown: boolean = true,
     readonly canUpdateOutput: boolean = false,
   ) {}
@@ -195,7 +195,7 @@ export abstract class DeclarativeTool<
     return {
       name: this.name,
       description: this.description,
-      parameters: this.parameterSchema,
+      parametersJsonSchema: this.parameterSchema,
     };
   }
 
@@ -281,14 +281,14 @@ export abstract class BaseTool<
    * @param description Description of what the tool does
    * @param isOutputMarkdown Whether the tool's output should be rendered as markdown
    * @param canUpdateOutput Whether the tool supports live (streaming) output
-   * @param parameterSchema Open API 3.0 Schema defining the parameters
+   * @param parameterSchema JSON Schema defining the parameters
    */
   constructor(
     readonly name: string,
     readonly displayName: string,
     readonly description: string,
     readonly icon: Icon,
-    readonly parameterSchema: Schema,
+    readonly parameterSchema: unknown,
     readonly isOutputMarkdown: boolean = true,
     readonly canUpdateOutput: boolean = false,
   ) {
diff --git a/packages/core/src/tools/web-fetch.ts b/packages/core/src/tools/web-fetch.ts
index c96cae6c..6733c38d 100644
--- a/packages/core/src/tools/web-fetch.ts
+++ b/packages/core/src/tools/web-fetch.ts
@@ -12,7 +12,6 @@ import {
   ToolConfirmationOutcome,
   Icon,
 } from './tools.js';
-import { Type } from '@google/genai';
 import { getErrorMessage } from '../utils/errors.js';
 import { Config, ApprovalMode } from '../config/config.js';
 import { getResponseText } from '../utils/generateContentResponseUtilities.js';
@@ -77,11 +76,11 @@ export class WebFetchTool extends BaseTool<WebFetchToolParams, ToolResult> {
           prompt: {
             description:
               'A comprehensive prompt that includes the URL(s) (up to 20) to fetch and specific instructions on how to process their content (e.g., "Summarize https://example.com/article and extract key points from https://another.com/data"). Must contain as least one URL starting with http:// or https://.',
-            type: Type.STRING,
+            type: 'string',
           },
         },
         required: ['prompt'],
-        type: Type.OBJECT,
+        type: 'object',
       },
     );
     const proxy = config.getProxy();
@@ -156,7 +155,10 @@ ${textContent}
   }
 
   validateParams(params: WebFetchToolParams): string | null {
-    const errors = SchemaValidator.validate(this.schema.parameters, params);
+    const errors = SchemaValidator.validate(
+      this.schema.parametersJsonSchema,
+      params,
+    );
     if (errors) {
       return errors;
     }
diff --git a/packages/core/src/tools/web-search.ts b/packages/core/src/tools/web-search.ts
index 480cc7e7..8fe29967 100644
--- a/packages/core/src/tools/web-search.ts
+++ b/packages/core/src/tools/web-search.ts
@@ -89,7 +89,10 @@ export class WebSearchTool extends BaseTool<
    * @returns An error message string if validation fails, null if valid
    */
   validateParams(params: WebSearchToolParams): string | null {
-    const errors = SchemaValidator.validate(this.schema.parameters, params);
+    const errors = SchemaValidator.validate(
+      this.schema.parametersJsonSchema,
+      params,
+    );
     if (errors) {
       return errors;
     }
diff --git a/packages/core/src/tools/write-file.ts b/packages/core/src/tools/write-file.ts
index b018d653..5cdba419 100644
--- a/packages/core/src/tools/write-file.ts
+++ b/packages/core/src/tools/write-file.ts
@@ -18,7 +18,6 @@ import {
   Icon,
 } from './tools.js';
 import { ToolErrorType } from './tool-error.js';
-import { Type } from '@google/genai';
 import { SchemaValidator } from '../utils/schemaValidator.js';
 import { makeRelative, shortenPath } from '../utils/paths.js';
 import { getErrorMessage, isNodeError } from '../utils/errors.js';
@@ -89,21 +88,24 @@ export class WriteFileTool
           file_path: {
             description:
               "The absolute path to the file to write to (e.g., '/home/user/project/file.txt'). Relative paths are not supported.",
-            type: Type.STRING,
+            type: 'string',
           },
           content: {
             description: 'The content to write to the file.',
-            type: Type.STRING,
+            type: 'string',
           },
         },
         required: ['file_path', 'content'],
-        type: Type.OBJECT,
+        type: 'object',
       },
     );
   }
 
   validateToolParams(params: WriteFileToolParams): string | null {
-    const errors = SchemaValidator.validate(this.schema.parameters, params);
+    const errors = SchemaValidator.validate(
+      this.schema.parametersJsonSchema,
+      params,
+    );
     if (errors) {
       return errors;
     }
diff --git a/packages/core/src/utils/schemaValidator.ts b/packages/core/src/utils/schemaValidator.ts
index cb025774..f397c0b1 100644
--- a/packages/core/src/utils/schemaValidator.ts
+++ b/packages/core/src/utils/schemaValidator.ts
@@ -4,7 +4,6 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import { Schema } from '@google/genai';
 import AjvPkg from 'ajv';
 // Ajv's ESM/CJS interop: use 'any' for compatibility as recommended by Ajv docs
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -19,50 +18,18 @@ export class SchemaValidator {
    * Returns null if the data confroms to the schema described by schema (or if schema
    *  is null). Otherwise, returns a string describing the error.
    */
-  static validate(schema: Schema | undefined, data: unknown): string | null {
+  static validate(schema: unknown | undefined, data: unknown): string | null {
     if (!schema) {
       return null;
     }
     if (typeof data !== 'object' || data === null) {
       return 'Value of params must be an object';
     }
-    const validate = ajValidator.compile(this.toObjectSchema(schema));
+    const validate = ajValidator.compile(schema);
     const valid = validate(data);
     if (!valid && validate.errors) {
       return ajValidator.errorsText(validate.errors, { dataVar: 'params' });
     }
     return null;
   }
-
-  /**
-   * Converts @google/genai's Schema to an object compatible with avj.
-   * This is necessary because it represents Types as an Enum (with
-   * UPPERCASE values) and minItems and minLength as strings, when they should be numbers.
-   */
-  private static toObjectSchema(schema: Schema): object {
-    const newSchema: Record<string, unknown> = { ...schema };
-    if (newSchema.anyOf && Array.isArray(newSchema.anyOf)) {
-      newSchema.anyOf = newSchema.anyOf.map((v) => this.toObjectSchema(v));
-    }
-    if (newSchema.items) {
-      newSchema.items = this.toObjectSchema(newSchema.items);
-    }
-    if (newSchema.properties && typeof newSchema.properties === 'object') {
-      const newProperties: Record<string, unknown> = {};
-      for (const [key, value] of Object.entries(newSchema.properties)) {
-        newProperties[key] = this.toObjectSchema(value as Schema);
-      }
-      newSchema.properties = newProperties;
-    }
-    if (newSchema.type) {
-      newSchema.type = String(newSchema.type).toLowerCase();
-    }
-    if (newSchema.minItems) {
-      newSchema.minItems = Number(newSchema.minItems);
-    }
-    if (newSchema.minLength) {
-      newSchema.minLength = Number(newSchema.minLength);
-    }
-    return newSchema;
-  }
 }

From 26fe587b441087ec6894ccf347fa9859f5feae81 Mon Sep 17 00:00:00 2001
From: Sandy Tao <sandytao520@icloud.com>
Date: Mon, 11 Aug 2025 16:45:31 -0700
Subject: [PATCH 100/107] skip loop check if it is currently inside a loop
 (#6022)

---
 .../src/services/loopDetectionService.test.ts | 74 +++++++++++++++++++
 .../core/src/services/loopDetectionService.ts |  2 +-
 2 files changed, 75 insertions(+), 1 deletion(-)

diff --git a/packages/core/src/services/loopDetectionService.test.ts b/packages/core/src/services/loopDetectionService.test.ts
index e5eeacd5..f579ba32 100644
--- a/packages/core/src/services/loopDetectionService.test.ts
+++ b/packages/core/src/services/loopDetectionService.test.ts
@@ -200,6 +200,80 @@ describe('LoopDetectionService', () => {
       expect(loggers.logLoopDetected).not.toHaveBeenCalled();
     });
 
+    it('should not detect loops when content transitions into a code block', () => {
+      service.reset('');
+      const repeatedContent = createRepetitiveContent(1, CONTENT_CHUNK_SIZE);
+
+      // Add some repetitive content outside of code block
+      for (let i = 0; i < CONTENT_LOOP_THRESHOLD - 2; i++) {
+        service.addAndCheck(createContentEvent(repeatedContent));
+      }
+
+      // Now transition into a code block - this should prevent loop detection
+      // even though we were already close to the threshold
+      const codeBlockStart = '```javascript\n';
+      const isLoop = service.addAndCheck(createContentEvent(codeBlockStart));
+      expect(isLoop).toBe(false);
+
+      // Continue adding repetitive content inside the code block - should not trigger loop
+      for (let i = 0; i < CONTENT_LOOP_THRESHOLD; i++) {
+        const isLoopInside = service.addAndCheck(
+          createContentEvent(repeatedContent),
+        );
+        expect(isLoopInside).toBe(false);
+      }
+
+      expect(loggers.logLoopDetected).not.toHaveBeenCalled();
+    });
+
+    it('should skip loop detection when already inside a code block (this.inCodeBlock)', () => {
+      service.reset('');
+
+      // Start with content that puts us inside a code block
+      service.addAndCheck(createContentEvent('Here is some code:\n```\n'));
+
+      // Verify we are now inside a code block and any content should be ignored for loop detection
+      const repeatedContent = createRepetitiveContent(1, CONTENT_CHUNK_SIZE);
+      for (let i = 0; i < CONTENT_LOOP_THRESHOLD + 5; i++) {
+        const isLoop = service.addAndCheck(createContentEvent(repeatedContent));
+        expect(isLoop).toBe(false);
+      }
+
+      expect(loggers.logLoopDetected).not.toHaveBeenCalled();
+    });
+
+    it('should correctly track inCodeBlock state with multiple fence transitions', () => {
+      service.reset('');
+      const repeatedContent = createRepetitiveContent(1, CONTENT_CHUNK_SIZE);
+
+      // Outside code block - should track content
+      service.addAndCheck(createContentEvent('Normal text '));
+
+      // Enter code block (1 fence) - should stop tracking
+      const enterResult = service.addAndCheck(createContentEvent('```\n'));
+      expect(enterResult).toBe(false);
+
+      // Inside code block - should not track loops
+      for (let i = 0; i < 5; i++) {
+        const insideResult = service.addAndCheck(
+          createContentEvent(repeatedContent),
+        );
+        expect(insideResult).toBe(false);
+      }
+
+      // Exit code block (2nd fence) - should reset tracking but still return false
+      const exitResult = service.addAndCheck(createContentEvent('```\n'));
+      expect(exitResult).toBe(false);
+
+      // Enter code block again (3rd fence) - should stop tracking again
+      const reenterResult = service.addAndCheck(
+        createContentEvent('```python\n'),
+      );
+      expect(reenterResult).toBe(false);
+
+      expect(loggers.logLoopDetected).not.toHaveBeenCalled();
+    });
+
     it('should detect a loop when repetitive content is outside a code block', () => {
       service.reset('');
       const repeatedContent = createRepetitiveContent(1, CONTENT_CHUNK_SIZE);
diff --git a/packages/core/src/services/loopDetectionService.ts b/packages/core/src/services/loopDetectionService.ts
index 409e92a8..f89e00da 100644
--- a/packages/core/src/services/loopDetectionService.ts
+++ b/packages/core/src/services/loopDetectionService.ts
@@ -179,7 +179,7 @@ export class LoopDetectionService {
     const wasInCodeBlock = this.inCodeBlock;
     this.inCodeBlock =
       numFences % 2 === 0 ? this.inCodeBlock : !this.inCodeBlock;
-    if (wasInCodeBlock) {
+    if (wasInCodeBlock || this.inCodeBlock) {
       return false;
     }
 

From d8fec54e817e74f2de533e511cfd31ae93f58963 Mon Sep 17 00:00:00 2001
From: Seth Vargo <seth@sethvargo.com>
Date: Mon, 11 Aug 2025 21:32:23 -0400
Subject: [PATCH 101/107] feat(/setup-github): Use node to download the files
 (#5863)

---
 .../ui/commands/setupGithubCommand.test.ts    |  54 ++++++++--
 .../cli/src/ui/commands/setupGithubCommand.ts | 102 ++++++++++++------
 packages/cli/src/utils/gitUtils.ts            |  10 +-
 3 files changed, 118 insertions(+), 48 deletions(-)

diff --git a/packages/cli/src/ui/commands/setupGithubCommand.test.ts b/packages/cli/src/ui/commands/setupGithubCommand.test.ts
index be0a657f..38589e58 100644
--- a/packages/cli/src/ui/commands/setupGithubCommand.test.ts
+++ b/packages/cli/src/ui/commands/setupGithubCommand.test.ts
@@ -4,10 +4,15 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
+import os from 'node:os';
+import path from 'node:path';
+import fs from 'node:fs/promises';
+
 import { vi, describe, expect, it, afterEach, beforeEach } from 'vitest';
 import * as gitUtils from '../../utils/gitUtils.js';
 import { setupGithubCommand } from './setupGithubCommand.js';
 import { CommandContext, ToolActionReturn } from './types.js';
+import * as commandUtils from '../utils/commandUtils.js';
 
 vi.mock('child_process');
 
@@ -21,21 +26,43 @@ vi.mock('../../utils/gitUtils.js', () => ({
   getGitHubRepoInfo: vi.fn(),
 }));
 
+vi.mock('../utils/commandUtils.js', () => ({
+  getUrlOpenCommand: vi.fn(),
+}));
+
 describe('setupGithubCommand', async () => {
-  beforeEach(() => {
+  let scratchDir = '';
+
+  beforeEach(async () => {
     vi.resetAllMocks();
+    scratchDir = await fs.mkdtemp(
+      path.join(os.tmpdir(), 'setup-github-command-'),
+    );
   });
 
-  afterEach(() => {
+  afterEach(async () => {
     vi.restoreAllMocks();
+    if (scratchDir) await fs.rm(scratchDir, { recursive: true });
   });
 
   it('returns a tool action to download github workflows and handles paths', async () => {
     const fakeRepoOwner = 'fake';
     const fakeRepoName = 'repo';
-    const fakeRepoRoot = `/github.com/${fakeRepoOwner}/${fakeRepoName}/root`;
+    const fakeRepoRoot = scratchDir;
     const fakeReleaseVersion = 'v1.2.3';
 
+    const workflows = [
+      'gemini-cli.yml',
+      'gemini-issue-automated-triage.yml',
+      'gemini-issue-scheduled-triage.yml',
+      'gemini-pr-review.yml',
+    ];
+    for (const workflow of workflows) {
+      vi.mocked(global.fetch).mockReturnValueOnce(
+        Promise.resolve(new Response(workflow)),
+      );
+    }
+
     vi.mocked(gitUtils.isGitHubRepository).mockReturnValueOnce(true);
     vi.mocked(gitUtils.getGitRepoRoot).mockReturnValueOnce(fakeRepoRoot);
     vi.mocked(gitUtils.getLatestGitHubRelease).mockResolvedValueOnce(
@@ -45,6 +72,9 @@ describe('setupGithubCommand', async () => {
       owner: fakeRepoOwner,
       repo: fakeRepoName,
     });
+    vi.mocked(commandUtils.getUrlOpenCommand).mockReturnValueOnce(
+      'fakeOpenCommand',
+    );
 
     const result = (await setupGithubCommand.action?.(
       {} as CommandContext,
@@ -55,16 +85,22 @@ describe('setupGithubCommand', async () => {
 
     const expectedSubstrings = [
       `set -eEuo pipefail`,
-      `mkdir -p "${fakeRepoRoot}/.github/workflows"`,
-      `curl --fail --location --output "/github.com/fake/repo/root/.github/workflows/gemini-cli.yml" --show-error --silent`,
-      `curl --fail --location --output "/github.com/fake/repo/root/.github/workflows/gemini-issue-automated-triage.yml" --show-error --silent`,
-      `curl --fail --location --output "/github.com/fake/repo/root/.github/workflows/gemini-issue-scheduled-triage.yml" --show-error --silent`,
-      `curl --fail --location --output "/github.com/fake/repo/root/.github/workflows/gemini-pr-review.yml" --show-error --silent`,
-      `https://raw.githubusercontent.com/google-github-actions/run-gemini-cli/refs/tags/`,
+      `fakeOpenCommand "https://github.com/google-github-actions/run-gemini-cli`,
     ];
 
     for (const substring of expectedSubstrings) {
       expect(command).toContain(substring);
     }
+
+    for (const workflow of workflows) {
+      const workflowFile = path.join(
+        scratchDir,
+        '.github',
+        'workflows',
+        workflow,
+      );
+      const contents = await fs.readFile(workflowFile, 'utf8');
+      expect(contents).toContain(workflow);
+    }
   });
 });
diff --git a/packages/cli/src/ui/commands/setupGithubCommand.ts b/packages/cli/src/ui/commands/setupGithubCommand.ts
index 84d6b5af..2f024e60 100644
--- a/packages/cli/src/ui/commands/setupGithubCommand.ts
+++ b/packages/cli/src/ui/commands/setupGithubCommand.ts
@@ -4,7 +4,10 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import path from 'path';
+import path from 'node:path';
+import * as fs from 'node:fs';
+import { Writable } from 'node:stream';
+import { ProxyAgent } from 'undici';
 
 import { CommandContext } from '../../ui/commands/types.js';
 import {
@@ -48,6 +51,8 @@ export const setupGithubCommand: SlashCommand = {
   action: async (
     context: CommandContext,
   ): Promise<SlashCommandActionReturn> => {
+    const abortController = new AbortController();
+
     if (!isGitHubRepository()) {
       throw new Error(
         'Unable to determine the GitHub repository. /setup-github must be run from a git repository.',
@@ -68,7 +73,24 @@ export const setupGithubCommand: SlashCommand = {
     // Get the latest release tag from GitHub
     const proxy = context?.services?.config?.getProxy();
     const releaseTag = await getLatestGitHubRelease(proxy);
+    const readmeUrl = `https://github.com/google-github-actions/run-gemini-cli/blob/${releaseTag}/README.md#quick-start`;
 
+    // Create the .github/workflows directory to download the files into
+    const githubWorkflowsDir = path.join(gitRepoRoot, '.github', 'workflows');
+    try {
+      await fs.promises.mkdir(githubWorkflowsDir, { recursive: true });
+    } catch (_error) {
+      console.debug(
+        `Failed to create ${githubWorkflowsDir} directory:`,
+        _error,
+      );
+      throw new Error(
+        `Unable to create ${githubWorkflowsDir} directory. Do you have file permissions in the current directory?`,
+      );
+    }
+
+    // Download each workflow in parallel - there aren't enough files to warrant
+    // a full workerpool model here.
     const workflows = [
       'gemini-cli/gemini-cli.yml',
       'issue-triage/gemini-issue-automated-triage.yml',
@@ -76,29 +98,60 @@ export const setupGithubCommand: SlashCommand = {
       'pr-review/gemini-pr-review.yml',
     ];
 
-    const commands = [];
-
-    // Ensure fast exit
-    commands.push(`set -eEuo pipefail`);
-
-    // Make the directory if it doesn't exist
-    commands.push(`mkdir -p "${gitRepoRoot}/.github/workflows"`);
-
+    const downloads = [];
     for (const workflow of workflows) {
-      const fileName = path.basename(workflow);
-      const curlCommand = buildCurlCommand(
-        `https://raw.githubusercontent.com/google-github-actions/run-gemini-cli/refs/tags/${releaseTag}/examples/workflows/${workflow}`,
-        [`--output "${gitRepoRoot}/.github/workflows/${fileName}"`],
+      downloads.push(
+        (async () => {
+          const endpoint = `https://raw.githubusercontent.com/google-github-actions/run-gemini-cli/refs/tags/${releaseTag}/examples/workflows/${workflow}`;
+          const response = await fetch(endpoint, {
+            method: 'GET',
+            dispatcher: proxy ? new ProxyAgent(proxy) : undefined,
+            signal: AbortSignal.any([
+              AbortSignal.timeout(30_000),
+              abortController.signal,
+            ]),
+          } as RequestInit);
+
+          if (!response.ok) {
+            throw new Error(
+              `Invalid response code downloading ${endpoint}: ${response.status} - ${response.statusText}`,
+            );
+          }
+          const body = response.body;
+          if (!body) {
+            throw new Error(
+              `Empty body while downloading ${endpoint}: ${response.status} - ${response.statusText}`,
+            );
+          }
+
+          const destination = path.resolve(
+            githubWorkflowsDir,
+            path.basename(workflow),
+          );
+
+          const fileStream = fs.createWriteStream(destination, {
+            mode: 0o644, // -rw-r--r--, user(rw), group(r), other(r)
+            flags: 'w', // write and overwrite
+            flush: true,
+          });
+
+          await body.pipeTo(Writable.toWeb(fileStream));
+        })(),
       );
-      commands.push(curlCommand);
     }
 
-    const readmeUrl = `https://github.com/google-github-actions/run-gemini-cli/blob/${releaseTag}/README.md#quick-start`;
+    // Wait for all downloads to complete
+    await Promise.all(downloads).finally(() => {
+      // Stop existing downloads
+      abortController.abort();
+    });
 
+    // Print out a message
+    const commands = [];
+    commands.push('set -eEuo pipefail');
     commands.push(
       `echo "Successfully downloaded ${workflows.length} workflows. Follow the steps in ${readmeUrl} (skipping the /setup-github step) to complete setup."`,
     );
-
     commands.push(...getOpenUrlsCommands(readmeUrl));
 
     const command = `(${commands.join(' && ')})`;
@@ -113,20 +166,3 @@ export const setupGithubCommand: SlashCommand = {
     };
   },
 };
-
-// buildCurlCommand is a helper for constructing a consistent curl command.
-function buildCurlCommand(u: string, additionalArgs?: string[]): string {
-  const args = [];
-  args.push('--fail');
-  args.push('--location');
-  args.push('--show-error');
-  args.push('--silent');
-
-  for (const val of additionalArgs || []) {
-    args.push(val);
-  }
-
-  args.sort();
-
-  return `curl ${args.join(' ')} "${u}"`;
-}
diff --git a/packages/cli/src/utils/gitUtils.ts b/packages/cli/src/utils/gitUtils.ts
index f5f9cb92..7b271ac4 100644
--- a/packages/cli/src/utils/gitUtils.ts
+++ b/packages/cli/src/utils/gitUtils.ts
@@ -5,7 +5,7 @@
  */
 
 import { execSync } from 'child_process';
-import { ProxyAgent, setGlobalDispatcher } from 'undici';
+import { ProxyAgent } from 'undici';
 
 /**
  * Checks if a directory is within a git repository hosted on GitHub.
@@ -57,9 +57,6 @@ export const getLatestGitHubRelease = async (
 ): Promise<string> => {
   try {
     const controller = new AbortController();
-    if (proxy) {
-      setGlobalDispatcher(new ProxyAgent(proxy));
-    }
 
     const endpoint = `https://api.github.com/repos/google-github-actions/run-gemini-cli/releases/latest`;
 
@@ -70,8 +67,9 @@ export const getLatestGitHubRelease = async (
         'Content-Type': 'application/json',
         'X-GitHub-Api-Version': '2022-11-28',
       },
-      signal: controller.signal,
-    });
+      dispatcher: proxy ? new ProxyAgent(proxy) : undefined,
+      signal: AbortSignal.any([AbortSignal.timeout(30_000), controller.signal]),
+    } as RequestInit);
 
     if (!response.ok) {
       throw new Error(

From f9efb2e24f41d8738d6ea8d1b8e8be2dff3bb83b Mon Sep 17 00:00:00 2001
From: Ali Al Jufairi <ali.redha.ali@gmail.com>
Date: Tue, 12 Aug 2025 13:08:35 +0900
Subject: [PATCH 102/107] docs(commands): add /settings command for
 user-friendly settings editing (#5984)

Co-authored-by: gemini-code-assist[bot] <176961590+gemini-code-assist[bot]@users.noreply.github.com>
---
 docs/cli/commands.md | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/docs/cli/commands.md b/docs/cli/commands.md
index c912ca2d..48fa9f3f 100644
--- a/docs/cli/commands.md
+++ b/docs/cli/commands.md
@@ -88,6 +88,11 @@ Slash commands provide meta-level control over the CLI itself.
   - **Usage:** `/restore [tool_call_id]`
   - **Note:** Only available if the CLI is invoked with the `--checkpointing` option or configured via [settings](./configuration.md). See [Checkpointing documentation](../checkpointing.md) for more details.
 
+- **`/settings`**
+  - **Description:** Open the settings editor to view and modify Gemini CLI settings.
+  - **Details:** This command provides a user-friendly interface for changing settings that control the behavior and appearance of Gemini CLI. It is equivalent to manually editing the `.gemini/settings.json` file, but with validation and guidance to prevent errors.
+  - **Usage:** Simply run `/settings` and the editor will open. You can then browse or search for specific settings, view their current values, and modify them as desired. Changes to some settings are applied immediately, while others require a restart.
+
 - **`/stats`**
   - **Description:** Display detailed statistics for the current Gemini CLI session, including token usage, cached token savings (when available), and session duration. Note: Cached token information is only displayed when cached tokens are being used, which occurs with API key authentication but not with OAuth authentication at this time.
 

From 2d1a6af890da1e9437cd1a1774e2c7fc7ad32957 Mon Sep 17 00:00:00 2001
From: JAYADITYA <96861162+JayadityaGit@users.noreply.github.com>
Date: Tue, 12 Aug 2025 09:43:57 +0530
Subject: [PATCH 103/107] feat(cli): support single Ctrl+C to cancel streaming,
 preserving double Ctrl+C to exit (#5838)

---
 packages/cli/src/ui/App.tsx                   |  5 ++
 .../messages/ToolConfirmationMessage.tsx      |  4 +-
 packages/cli/src/ui/hooks/useGeminiStream.ts  | 52 ++++++++++++-------
 3 files changed, 40 insertions(+), 21 deletions(-)

diff --git a/packages/cli/src/ui/App.tsx b/packages/cli/src/ui/App.tsx
index c4f67294..e952d6b2 100644
--- a/packages/cli/src/ui/App.tsx
+++ b/packages/cli/src/ui/App.tsx
@@ -545,6 +545,7 @@ const App = ({ config, settings, startupWarnings = [], version }: AppProps) => {
     initError,
     pendingHistoryItems: pendingGeminiHistoryItems,
     thought,
+    cancelOngoingRequest,
   } = useGeminiStream(
     config.getGeminiClient(),
     history,
@@ -655,6 +656,9 @@ const App = ({ config, settings, startupWarnings = [], version }: AppProps) => {
         if (isAuthenticating) {
           return;
         }
+        if (!ctrlCPressedOnce) {
+          cancelOngoingRequest?.();
+        }
         handleExit(ctrlCPressedOnce, setCtrlCPressedOnce, ctrlCTimerRef);
       } else if (keyMatchers[Command.EXIT](key)) {
         if (buffer.text.length > 0) {
@@ -686,6 +690,7 @@ const App = ({ config, settings, startupWarnings = [], version }: AppProps) => {
       ctrlDTimerRef,
       handleSlashCommand,
       isAuthenticating,
+      cancelOngoingRequest,
     ],
   );
 
diff --git a/packages/cli/src/ui/components/messages/ToolConfirmationMessage.tsx b/packages/cli/src/ui/components/messages/ToolConfirmationMessage.tsx
index fcdb743f..88b25b86 100644
--- a/packages/cli/src/ui/components/messages/ToolConfirmationMessage.tsx
+++ b/packages/cli/src/ui/components/messages/ToolConfirmationMessage.tsx
@@ -56,9 +56,9 @@ export const ToolConfirmationMessage: React.FC<
     onConfirm(outcome);
   };
 
-  useInput((_, key) => {
+  useInput((input, key) => {
     if (!isFocused) return;
-    if (key.escape) {
+    if (key.escape || (key.ctrl && (input === 'c' || input === 'C'))) {
       handleConfirm(ToolConfirmationOutcome.Cancel);
     }
   });
diff --git a/packages/cli/src/ui/hooks/useGeminiStream.ts b/packages/cli/src/ui/hooks/useGeminiStream.ts
index 58bec431..6385d267 100644
--- a/packages/cli/src/ui/hooks/useGeminiStream.ts
+++ b/packages/cli/src/ui/hooks/useGeminiStream.ts
@@ -183,26 +183,39 @@ export const useGeminiStream = (
     return StreamingState.Idle;
   }, [isResponding, toolCalls]);
 
+  const cancelOngoingRequest = useCallback(() => {
+    if (streamingState !== StreamingState.Responding) {
+      return;
+    }
+    if (turnCancelledRef.current) {
+      return;
+    }
+    turnCancelledRef.current = true;
+    abortControllerRef.current?.abort();
+    if (pendingHistoryItemRef.current) {
+      addItem(pendingHistoryItemRef.current, Date.now());
+    }
+    addItem(
+      {
+        type: MessageType.INFO,
+        text: 'Request cancelled.',
+      },
+      Date.now(),
+    );
+    setPendingHistoryItem(null);
+    onCancelSubmit();
+    setIsResponding(false);
+  }, [
+    streamingState,
+    addItem,
+    setPendingHistoryItem,
+    onCancelSubmit,
+    pendingHistoryItemRef,
+  ]);
+
   useInput((_input, key) => {
-    if (streamingState === StreamingState.Responding && key.escape) {
-      if (turnCancelledRef.current) {
-        return;
-      }
-      turnCancelledRef.current = true;
-      abortControllerRef.current?.abort();
-      if (pendingHistoryItemRef.current) {
-        addItem(pendingHistoryItemRef.current, Date.now());
-      }
-      addItem(
-        {
-          type: MessageType.INFO,
-          text: 'Request cancelled.',
-        },
-        Date.now(),
-      );
-      setPendingHistoryItem(null);
-      onCancelSubmit();
-      setIsResponding(false);
+    if (key.escape) {
+      cancelOngoingRequest();
     }
   });
 
@@ -954,5 +967,6 @@ export const useGeminiStream = (
     initError,
     pendingHistoryItems,
     thought,
+    cancelOngoingRequest,
   };
 };

From 804c181ac4a3dc1c4971a5b8a643421bbe697f3d Mon Sep 17 00:00:00 2001
From: Jacob Richman <jacob314@gmail.com>
Date: Tue, 12 Aug 2025 09:19:09 -0700
Subject: [PATCH 104/107] chore(integration-tests): refactor to typescript
 (#5645)

---
 .github/workflows/ci.yml                      |   8 ++
 ...ile-system.test.js => file-system.test.ts} |   0
 ...arch.test.js => google_web_search.test.ts} |   9 +-
 ...rectory.test.js => list_directory.test.ts} |   4 +-
 ..._files.test.js => read_many_files.test.ts} |   0
 .../{replace.test.js => replace.test.ts}      |   0
 integration-tests/run-tests.js                |   8 +-
 ...mand.test.js => run_shell_command.test.ts} |   0
 ...ave_memory.test.js => save_memory.test.ts} |   0
 ...rver.test.js => simple-mcp-server.test.ts} |   5 +-
 .../{test-helper.js => test-helper.ts}        | 133 ++++++++++++------
 integration-tests/tsconfig.json               |   8 ++
 ...{write_file.test.js => write_file.test.ts} |   0
 package-lock.json                             |  44 ++++++
 package.json                                  |   1 +
 15 files changed, 163 insertions(+), 57 deletions(-)
 rename integration-tests/{file-system.test.js => file-system.test.ts} (100%)
 rename integration-tests/{google_web_search.test.js => google_web_search.test.ts} (90%)
 rename integration-tests/{list_directory.test.js => list_directory.test.ts} (94%)
 rename integration-tests/{read_many_files.test.js => read_many_files.test.ts} (100%)
 rename integration-tests/{replace.test.js => replace.test.ts} (100%)
 rename integration-tests/{run_shell_command.test.js => run_shell_command.test.ts} (100%)
 rename integration-tests/{save_memory.test.js => save_memory.test.ts} (100%)
 rename integration-tests/{simple-mcp-server.test.js => simple-mcp-server.test.ts} (96%)
 rename integration-tests/{test-helper.js => test-helper.ts} (85%)
 create mode 100644 integration-tests/tsconfig.json
 rename integration-tests/{write_file.test.js => write_file.test.ts} (100%)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index ddc1288d..d34f39a3 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -36,6 +36,14 @@ jobs:
       - name: Run linter
         run: npm run lint:ci
 
+      - name: Run linter on integration tests
+        run: npx eslint integration-tests --max-warnings 0
+
+      - name: Run formatter on integration tests
+        run: |
+          npx prettier --check integration-tests
+          git diff --exit-code
+
       - name: Build project
         run: npm run build
 
diff --git a/integration-tests/file-system.test.js b/integration-tests/file-system.test.ts
similarity index 100%
rename from integration-tests/file-system.test.js
rename to integration-tests/file-system.test.ts
diff --git a/integration-tests/google_web_search.test.js b/integration-tests/google_web_search.test.ts
similarity index 90%
rename from integration-tests/google_web_search.test.js
rename to integration-tests/google_web_search.test.ts
index 31747421..6fb365a0 100644
--- a/integration-tests/google_web_search.test.js
+++ b/integration-tests/google_web_search.test.ts
@@ -18,10 +18,13 @@ test('should be able to search the web', async () => {
   } catch (error) {
     // Network errors can occur in CI environments
     if (
-      error.message.includes('network') ||
-      error.message.includes('timeout')
+      error instanceof Error &&
+      (error.message.includes('network') || error.message.includes('timeout'))
     ) {
-      console.warn('Skipping test due to network error:', error.message);
+      console.warn(
+        'Skipping test due to network error:',
+        (error as Error).message,
+      );
       return; // Skip the test
     }
     throw error; // Re-throw if not a network error
diff --git a/integration-tests/list_directory.test.js b/integration-tests/list_directory.test.ts
similarity index 94%
rename from integration-tests/list_directory.test.js
rename to integration-tests/list_directory.test.ts
index 16f49f4b..023eca12 100644
--- a/integration-tests/list_directory.test.js
+++ b/integration-tests/list_directory.test.ts
@@ -21,8 +21,8 @@ test('should be able to list a directory', async () => {
   await rig.poll(
     () => {
       // Check if the files exist in the test directory
-      const file1Path = join(rig.testDir, 'file1.txt');
-      const subdirPath = join(rig.testDir, 'subdir');
+      const file1Path = join(rig.testDir!, 'file1.txt');
+      const subdirPath = join(rig.testDir!, 'subdir');
       return existsSync(file1Path) && existsSync(subdirPath);
     },
     1000, // 1 second max wait
diff --git a/integration-tests/read_many_files.test.js b/integration-tests/read_many_files.test.ts
similarity index 100%
rename from integration-tests/read_many_files.test.js
rename to integration-tests/read_many_files.test.ts
diff --git a/integration-tests/replace.test.js b/integration-tests/replace.test.ts
similarity index 100%
rename from integration-tests/replace.test.js
rename to integration-tests/replace.test.ts
diff --git a/integration-tests/run-tests.js b/integration-tests/run-tests.js
index 05fb349e..b33e1afa 100644
--- a/integration-tests/run-tests.js
+++ b/integration-tests/run-tests.js
@@ -52,13 +52,13 @@ async function main() {
 
   const testPatterns =
     args.length > 0
-      ? args.map((arg) => `integration-tests/${arg}.test.js`)
-      : ['integration-tests/*.test.js'];
+      ? args.map((arg) => `integration-tests/${arg}.test.ts`)
+      : ['integration-tests/*.test.ts'];
   const testFiles = glob.sync(testPatterns, { cwd: rootDir, absolute: true });
 
   for (const testFile of testFiles) {
     const testFileName = basename(testFile);
-    console.log(`\tFound test file: ${testFileName}`);
+    console.log(`	Found test file: ${testFileName}`);
   }
 
   const MAX_RETRIES = 3;
@@ -92,7 +92,7 @@ async function main() {
       }
       nodeArgs.push(testFile);
 
-      const child = spawn('node', nodeArgs, {
+      const child = spawn('npx', ['tsx', ...nodeArgs], {
         stdio: 'pipe',
         env: {
           ...process.env,
diff --git a/integration-tests/run_shell_command.test.js b/integration-tests/run_shell_command.test.ts
similarity index 100%
rename from integration-tests/run_shell_command.test.js
rename to integration-tests/run_shell_command.test.ts
diff --git a/integration-tests/save_memory.test.js b/integration-tests/save_memory.test.ts
similarity index 100%
rename from integration-tests/save_memory.test.js
rename to integration-tests/save_memory.test.ts
diff --git a/integration-tests/simple-mcp-server.test.js b/integration-tests/simple-mcp-server.test.ts
similarity index 96%
rename from integration-tests/simple-mcp-server.test.js
rename to integration-tests/simple-mcp-server.test.ts
index 987f69d2..c4191078 100644
--- a/integration-tests/simple-mcp-server.test.js
+++ b/integration-tests/simple-mcp-server.test.ts
@@ -14,11 +14,8 @@ import { test, describe, before } from 'node:test';
 import { strict as assert } from 'node:assert';
 import { TestRig, validateModelOutput } from './test-helper.js';
 import { join } from 'path';
-import { fileURLToPath } from 'url';
 import { writeFileSync } from 'fs';
 
-const __dirname = fileURLToPath(new URL('.', import.meta.url));
-
 // Create a minimal MCP server that doesn't require external dependencies
 // This implements the MCP protocol directly using Node.js built-ins
 const serverScript = `#!/usr/bin/env node
@@ -185,7 +182,7 @@ describe('simple-mcp-server', () => {
     });
 
     // Create server script in the test directory
-    const testServerPath = join(rig.testDir, 'mcp-server.cjs');
+    const testServerPath = join(rig.testDir!, 'mcp-server.cjs');
     writeFileSync(testServerPath, serverScript);
 
     // Make the script executable (though running with 'node' should work anyway)
diff --git a/integration-tests/test-helper.js b/integration-tests/test-helper.ts
similarity index 85%
rename from integration-tests/test-helper.js
rename to integration-tests/test-helper.ts
index d1125a78..33443aaf 100644
--- a/integration-tests/test-helper.js
+++ b/integration-tests/test-helper.ts
@@ -14,7 +14,7 @@ import { fileExists } from '../scripts/telemetry_utils.js';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 
-function sanitizeTestName(name) {
+function sanitizeTestName(name: string) {
   return name
     .toLowerCase()
     .replace(/[^a-z0-9]/g, '-')
@@ -22,7 +22,11 @@ function sanitizeTestName(name) {
 }
 
 // Helper to create detailed error messages
-export function createToolCallErrorMessage(expectedTools, foundTools, result) {
+export function createToolCallErrorMessage(
+  expectedTools: string | string[],
+  foundTools: string[],
+  result: string,
+) {
   const expectedStr = Array.isArray(expectedTools)
     ? expectedTools.join(' or ')
     : expectedTools;
@@ -34,7 +38,11 @@ export function createToolCallErrorMessage(expectedTools, foundTools, result) {
 }
 
 // Helper to print debug information when tests fail
-export function printDebugInfo(rig, result, context = {}) {
+export function printDebugInfo(
+  rig: TestRig,
+  result: string,
+  context: Record<string, unknown> = {},
+) {
   console.error('Test failed - Debug info:');
   console.error('Result length:', result.length);
   console.error('Result (first 500 chars):', result.substring(0, 500));
@@ -60,8 +68,8 @@ export function printDebugInfo(rig, result, context = {}) {
 
 // Helper to validate model output and warn about unexpected content
 export function validateModelOutput(
-  result,
-  expectedContent = null,
+  result: string,
+  expectedContent: string | (string | RegExp)[] | null = null,
   testName = '',
 ) {
   // First, check if there's any output at all (this should fail the test if missing)
@@ -102,6 +110,11 @@ export function validateModelOutput(
 }
 
 export class TestRig {
+  bundlePath: string;
+  testDir: string | null;
+  testName?: string;
+  _lastRunStdout?: string;
+
   constructor() {
     this.bundlePath = join(__dirname, '..', 'bundle/gemini.js');
     this.testDir = null;
@@ -114,10 +127,13 @@ export class TestRig {
     return 15000; // 15s locally
   }
 
-  setup(testName, options = {}) {
+  setup(
+    testName: string,
+    options: { settings?: Record<string, unknown> } = {},
+  ) {
     this.testName = testName;
     const sanitizedName = sanitizeTestName(testName);
-    this.testDir = join(env.INTEGRATION_TEST_FILE_DIR, sanitizedName);
+    this.testDir = join(env.INTEGRATION_TEST_FILE_DIR!, sanitizedName);
     mkdirSync(this.testDir, { recursive: true });
 
     // Create a settings file to point the CLI to the local collector
@@ -146,25 +162,32 @@ export class TestRig {
     );
   }
 
-  createFile(fileName, content) {
-    const filePath = join(this.testDir, fileName);
+  createFile(fileName: string, content: string) {
+    const filePath = join(this.testDir!, fileName);
     writeFileSync(filePath, content);
     return filePath;
   }
 
-  mkdir(dir) {
-    mkdirSync(join(this.testDir, dir), { recursive: true });
+  mkdir(dir: string) {
+    mkdirSync(join(this.testDir!, dir), { recursive: true });
   }
 
   sync() {
     // ensure file system is done before spawning
-    execSync('sync', { cwd: this.testDir });
+    execSync('sync', { cwd: this.testDir! });
   }
 
-  run(promptOrOptions, ...args) {
+  run(
+    promptOrOptions: string | { prompt?: string; stdin?: string },
+    ...args: string[]
+  ): Promise<string> {
     let command = `node ${this.bundlePath} --yolo`;
-    const execOptions = {
-      cwd: this.testDir,
+    const execOptions: {
+      cwd: string;
+      encoding: 'utf-8';
+      input?: string;
+    } = {
+      cwd: this.testDir!,
       encoding: 'utf-8',
     };
 
@@ -185,10 +208,10 @@ export class TestRig {
     command += ` ${args.join(' ')}`;
 
     const commandArgs = parse(command);
-    const node = commandArgs.shift();
+    const node = commandArgs.shift() as string;
 
-    const child = spawn(node, commandArgs, {
-      cwd: this.testDir,
+    const child = spawn(node, commandArgs as string[], {
+      cwd: this.testDir!,
       stdio: 'pipe',
     });
 
@@ -197,26 +220,26 @@ export class TestRig {
 
     // Handle stdin if provided
     if (execOptions.input) {
-      child.stdin.write(execOptions.input);
-      child.stdin.end();
+      child.stdin!.write(execOptions.input);
+      child.stdin!.end();
     }
 
-    child.stdout.on('data', (data) => {
+    child.stdout!.on('data', (data: Buffer) => {
       stdout += data;
       if (env.KEEP_OUTPUT === 'true' || env.VERBOSE === 'true') {
         process.stdout.write(data);
       }
     });
 
-    child.stderr.on('data', (data) => {
+    child.stderr!.on('data', (data: Buffer) => {
       stderr += data;
       if (env.KEEP_OUTPUT === 'true' || env.VERBOSE === 'true') {
         process.stderr.write(data);
       }
     });
 
-    const promise = new Promise((resolve, reject) => {
-      child.on('close', (code) => {
+    const promise = new Promise<string>((resolve, reject) => {
+      child.on('close', (code: number) => {
         if (code === 0) {
           // Store the raw stdout for Podman telemetry parsing
           this._lastRunStdout = stdout;
@@ -273,13 +296,13 @@ export class TestRig {
     return promise;
   }
 
-  readFile(fileName) {
-    const content = readFileSync(join(this.testDir, fileName), 'utf-8');
+  readFile(fileName: string) {
+    const content = readFileSync(join(this.testDir!, fileName), 'utf-8');
     if (env.KEEP_OUTPUT === 'true' || env.VERBOSE === 'true') {
-      const testId = `${env.TEST_FILE_NAME.replace(
+      const testId = `${env.TEST_FILE_NAME!.replace(
         '.test.js',
         '',
-      )}:${this.testName.replace(/ /g, '-')}`;
+      )}:${this.testName!.replace(/ /g, '-')}`;
       console.log(`--- FILE: ${testId}/${fileName} ---`);
       console.log(content);
       console.log(`--- END FILE: ${testId}/${fileName} ---`);
@@ -295,7 +318,7 @@ export class TestRig {
       } catch (error) {
         // Ignore cleanup errors
         if (env.VERBOSE === 'true') {
-          console.warn('Cleanup warning:', error.message);
+          console.warn('Cleanup warning:', (error as Error).message);
         }
       }
     }
@@ -305,7 +328,7 @@ export class TestRig {
     // In sandbox mode, telemetry is written to a relative path in the test directory
     const logFilePath =
       env.GEMINI_SANDBOX && env.GEMINI_SANDBOX !== 'false'
-        ? join(this.testDir, 'telemetry.log')
+        ? join(this.testDir!, 'telemetry.log')
         : env.TELEMETRY_LOG_FILE;
 
     if (!logFilePath) return;
@@ -318,7 +341,7 @@ export class TestRig {
           const content = readFileSync(logFilePath, 'utf-8');
           // Check if file has meaningful content (at least one complete JSON object)
           return content.includes('"event.name"');
-        } catch (_e) {
+        } catch {
           return false;
         }
       },
@@ -327,7 +350,7 @@ export class TestRig {
     );
   }
 
-  async waitForToolCall(toolName, timeout) {
+  async waitForToolCall(toolName: string, timeout?: number) {
     // Use environment-specific timeout
     if (!timeout) {
       timeout = this.getDefaultTimeout();
@@ -346,7 +369,7 @@ export class TestRig {
     );
   }
 
-  async waitForAnyToolCall(toolNames, timeout) {
+  async waitForAnyToolCall(toolNames: string[], timeout?: number) {
     // Use environment-specific timeout
     if (!timeout) {
       timeout = this.getDefaultTimeout();
@@ -367,7 +390,11 @@ export class TestRig {
     );
   }
 
-  async poll(predicate, timeout, interval) {
+  async poll(
+    predicate: () => boolean,
+    timeout: number,
+    interval: number,
+  ): Promise<boolean> {
     const startTime = Date.now();
     let attempts = 0;
     while (Date.now() - startTime < timeout) {
@@ -389,8 +416,16 @@ export class TestRig {
     return false;
   }
 
-  _parseToolLogsFromStdout(stdout) {
-    const logs = [];
+  _parseToolLogsFromStdout(stdout: string) {
+    const logs: {
+      timestamp: number;
+      toolRequest: {
+        name: string;
+        args: string;
+        success: boolean;
+        duration_ms: number;
+      };
+    }[] = [];
 
     // The console output from Podman is JavaScript object notation, not JSON
     // Look for tool call events in the output
@@ -493,7 +528,7 @@ export class TestRig {
                   },
                 });
               }
-            } catch (_e) {
+            } catch {
               // Not valid JSON
             }
             currentObject = '';
@@ -510,7 +545,7 @@ export class TestRig {
     // If not, fall back to parsing from stdout
     if (env.GEMINI_SANDBOX === 'podman') {
       // Try reading from file first
-      const logFilePath = join(this.testDir, 'telemetry.log');
+      const logFilePath = join(this.testDir!, 'telemetry.log');
 
       if (fileExists(logFilePath)) {
         try {
@@ -522,7 +557,7 @@ export class TestRig {
             // File exists but is empty or doesn't have events, parse from stdout
             return this._parseToolLogsFromStdout(this._lastRunStdout);
           }
-        } catch (_e) {
+        } catch {
           // Error reading file, fall back to stdout
           if (this._lastRunStdout) {
             return this._parseToolLogsFromStdout(this._lastRunStdout);
@@ -537,7 +572,7 @@ export class TestRig {
     // In sandbox mode, telemetry is written to a relative path in the test directory
     const logFilePath =
       env.GEMINI_SANDBOX && env.GEMINI_SANDBOX !== 'false'
-        ? join(this.testDir, 'telemetry.log')
+        ? join(this.testDir!, 'telemetry.log')
         : env.TELEMETRY_LOG_FILE;
 
     if (!logFilePath) {
@@ -553,7 +588,7 @@ export class TestRig {
     const content = readFileSync(logFilePath, 'utf-8');
 
     // Split the content into individual JSON objects
-    // They are separated by "}\n{" pattern
+    // They are separated by "}\n{"
     const jsonObjects = content
       .split(/}\s*\n\s*{/)
       .map((obj, index, array) => {
@@ -564,7 +599,14 @@ export class TestRig {
       })
       .filter((obj) => obj);
 
-    const logs = [];
+    const logs: {
+      toolRequest: {
+        name: string;
+        args: string;
+        success: boolean;
+        duration_ms: number;
+      };
+    }[] = [];
 
     for (const jsonStr of jsonObjects) {
       try {
@@ -584,10 +626,13 @@ export class TestRig {
             },
           });
         }
-      } catch (_e) {
+      } catch (e) {
         // Skip objects that aren't valid JSON
         if (env.VERBOSE === 'true') {
-          console.error('Failed to parse telemetry object:', _e.message);
+          console.error(
+            'Failed to parse telemetry object:',
+            (e as Error).message,
+          );
         }
       }
     }
diff --git a/integration-tests/tsconfig.json b/integration-tests/tsconfig.json
new file mode 100644
index 00000000..3e053d04
--- /dev/null
+++ b/integration-tests/tsconfig.json
@@ -0,0 +1,8 @@
+{
+  "extends": "../tsconfig.json",
+  "compilerOptions": {
+    "noEmit": true,
+    "allowJs": true
+  },
+  "include": ["**/*.ts"]
+}
diff --git a/integration-tests/write_file.test.js b/integration-tests/write_file.test.ts
similarity index 100%
rename from integration-tests/write_file.test.js
rename to integration-tests/write_file.test.ts
diff --git a/package-lock.json b/package-lock.json
index 9ee6b751..dfe65ded 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -39,6 +39,7 @@
         "mock-fs": "^5.5.0",
         "prettier": "^3.5.3",
         "react-devtools-core": "^4.28.5",
+        "tsx": "^4.20.3",
         "typescript-eslint": "^8.30.1",
         "vitest": "^3.2.4",
         "yargs": "^17.7.2"
@@ -5692,6 +5693,19 @@
         "url": "https://github.com/sponsors/ljharb"
       }
     },
+    "node_modules/get-tsconfig": {
+      "version": "4.10.1",
+      "resolved": "https://registry.npmjs.org/get-tsconfig/-/get-tsconfig-4.10.1.tgz",
+      "integrity": "sha512-auHyJ4AgMz7vgS8Hp3N6HXSmlMdUyhSUrfBF16w153rxtLIEOE+HGqaBppczZvnHLqQJfiHotCYpNhl0lUROFQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "resolve-pkg-maps": "^1.0.0"
+      },
+      "funding": {
+        "url": "https://github.com/privatenumber/get-tsconfig?sponsor=1"
+      }
+    },
     "node_modules/glob": {
       "version": "10.4.5",
       "resolved": "https://registry.npmjs.org/glob/-/glob-10.4.5.tgz",
@@ -9262,6 +9276,16 @@
         "node": ">=4"
       }
     },
+    "node_modules/resolve-pkg-maps": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/resolve-pkg-maps/-/resolve-pkg-maps-1.0.0.tgz",
+      "integrity": "sha512-seS2Tj26TBVOC2NIc2rOe2y2ZO7efxITtLZcGSOnHHNOQ7CkiUBfw0Iw2ck6xkIhPwLhKNLS8BO+hEpngQlqzw==",
+      "dev": true,
+      "license": "MIT",
+      "funding": {
+        "url": "https://github.com/privatenumber/resolve-pkg-maps?sponsor=1"
+      }
+    },
     "node_modules/restore-cursor": {
       "version": "4.0.0",
       "resolved": "https://registry.npmjs.org/restore-cursor/-/restore-cursor-4.0.0.tgz",
@@ -10562,6 +10586,26 @@
       "dev": true,
       "license": "0BSD"
     },
+    "node_modules/tsx": {
+      "version": "4.20.3",
+      "resolved": "https://registry.npmjs.org/tsx/-/tsx-4.20.3.tgz",
+      "integrity": "sha512-qjbnuR9Tr+FJOMBqJCW5ehvIo/buZq7vH7qD7JziU98h6l3qGy0a/yPFjwO+y0/T7GFpNgNAvEcPPVfyT8rrPQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "esbuild": "~0.25.0",
+        "get-tsconfig": "^4.7.5"
+      },
+      "bin": {
+        "tsx": "dist/cli.mjs"
+      },
+      "engines": {
+        "node": ">=18.0.0"
+      },
+      "optionalDependencies": {
+        "fsevents": "~2.3.3"
+      }
+    },
     "node_modules/type-check": {
       "version": "0.4.0",
       "resolved": "https://registry.npmjs.org/type-check/-/type-check-0.4.0.tgz",
diff --git a/package.json b/package.json
index 0ba06955..637fc445 100644
--- a/package.json
+++ b/package.json
@@ -82,6 +82,7 @@
     "mock-fs": "^5.5.0",
     "prettier": "^3.5.3",
     "react-devtools-core": "^4.28.5",
+    "tsx": "^4.20.3",
     "typescript-eslint": "^8.30.1",
     "vitest": "^3.2.4",
     "yargs": "^17.7.2",

From 5d1d40fa2ef418ef707aa29215594a8f22e4dadb Mon Sep 17 00:00:00 2001
From: owenofbrien <86964623+owenofbrien@users.noreply.github.com>
Date: Tue, 12 Aug 2025 11:51:21 -0500
Subject: [PATCH 105/107] Fix: log api response error status codes (#6015)

Co-authored-by: Gaurav <39389231+gsquared94@users.noreply.github.com>
---
 .../core/src/core/loggingContentGenerator.ts     | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)

diff --git a/packages/core/src/core/loggingContentGenerator.ts b/packages/core/src/core/loggingContentGenerator.ts
index 305b19a4..13bd6918 100644
--- a/packages/core/src/core/loggingContentGenerator.ts
+++ b/packages/core/src/core/loggingContentGenerator.ts
@@ -28,6 +28,19 @@ import {
 import { ContentGenerator } from './contentGenerator.js';
 import { toContents } from '../code_assist/converter.js';
 
+interface StructuredError {
+  status: number;
+}
+
+export function isStructuredError(error: unknown): error is StructuredError {
+  return (
+    typeof error === 'object' &&
+    error !== null &&
+    'status' in error &&
+    typeof (error as StructuredError).status === 'number'
+  );
+}
+
 /**
  * A decorator that wraps a ContentGenerator to add logging to API calls.
  */
@@ -85,6 +98,9 @@ export class LoggingContentGenerator implements ContentGenerator {
         prompt_id,
         this.config.getContentGeneratorConfig()?.authType,
         errorType,
+        isStructuredError(error)
+          ? (error as StructuredError).status
+          : undefined,
       ),
     );
   }

From 67c60331472c2c43737c1a246746eb596aa3b56f Mon Sep 17 00:00:00 2001
From: Shreya Keshive <skeshive@gmail.com>
Date: Tue, 12 Aug 2025 14:03:55 -0400
Subject: [PATCH 106/107] Bump version number of companion extension to match
 next Gemini CLI version number (#6065)

---
 package-lock.json                             |    2 +-
 .../vscode-ide-companion/package-lock.json    | 4986 -----------------
 packages/vscode-ide-companion/package.json    |    2 +-
 3 files changed, 2 insertions(+), 4988 deletions(-)
 delete mode 100644 packages/vscode-ide-companion/package-lock.json

diff --git a/package-lock.json b/package-lock.json
index dfe65ded..bcce33b5 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -12071,7 +12071,7 @@
     },
     "packages/vscode-ide-companion": {
       "name": "gemini-cli-vscode-ide-companion",
-      "version": "0.0.1",
+      "version": "0.1.19",
       "license": "LICENSE",
       "dependencies": {
         "@modelcontextprotocol/sdk": "^1.15.1",
diff --git a/packages/vscode-ide-companion/package-lock.json b/packages/vscode-ide-companion/package-lock.json
deleted file mode 100644
index a35feadc..00000000
--- a/packages/vscode-ide-companion/package-lock.json
+++ /dev/null
@@ -1,4986 +0,0 @@
-{
-  "name": "gemini-cli-vscode",
-  "version": "0.0.1",
-  "lockfileVersion": 3,
-  "requires": true,
-  "packages": {
-    "": {
-      "name": "gemini-cli-vscode",
-      "version": "0.0.1",
-      "dependencies": {
-        "@modelcontextprotocol/sdk": "^1.15.1",
-        "cors": "^2.8.5",
-        "express": "^5.1.0",
-        "zod": "^3.25.76"
-      },
-      "devDependencies": {
-        "@types/cors": "^2.8.19",
-        "@types/express": "^5.0.3",
-        "@types/node": "20.x",
-        "@types/vscode": "^1.101.0",
-        "@typescript-eslint/eslint-plugin": "^8.31.1",
-        "@typescript-eslint/parser": "^8.31.1",
-        "esbuild": "^0.25.3",
-        "eslint": "^9.25.1",
-        "npm-run-all": "^4.1.5",
-        "typescript": "^5.8.3"
-      },
-      "engines": {
-        "vscode": "^1.101.0"
-      }
-    },
-    "node_modules/@esbuild/aix-ppc64": {
-      "version": "0.25.6",
-      "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.25.6.tgz",
-      "integrity": "sha512-ShbM/3XxwuxjFiuVBHA+d3j5dyac0aEVVq1oluIDf71hUw0aRF59dV/efUsIwFnR6m8JNM2FjZOzmaZ8yG61kw==",
-      "cpu": [
-        "ppc64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "aix"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@esbuild/android-arm": {
-      "version": "0.25.6",
-      "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.25.6.tgz",
-      "integrity": "sha512-S8ToEOVfg++AU/bHwdksHNnyLyVM+eMVAOf6yRKFitnwnbwwPNqKr3srzFRe7nzV69RQKb5DgchIX5pt3L53xg==",
-      "cpu": [
-        "arm"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "android"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@esbuild/android-arm64": {
-      "version": "0.25.6",
-      "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.25.6.tgz",
-      "integrity": "sha512-hd5zdUarsK6strW+3Wxi5qWws+rJhCCbMiC9QZyzoxfk5uHRIE8T287giQxzVpEvCwuJ9Qjg6bEjcRJcgfLqoA==",
-      "cpu": [
-        "arm64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "android"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@esbuild/android-x64": {
-      "version": "0.25.6",
-      "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.25.6.tgz",
-      "integrity": "sha512-0Z7KpHSr3VBIO9A/1wcT3NTy7EB4oNC4upJ5ye3R7taCc2GUdeynSLArnon5G8scPwaU866d3H4BCrE5xLW25A==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "android"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@esbuild/darwin-arm64": {
-      "version": "0.25.6",
-      "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.25.6.tgz",
-      "integrity": "sha512-FFCssz3XBavjxcFxKsGy2DYK5VSvJqa6y5HXljKzhRZ87LvEi13brPrf/wdyl/BbpbMKJNOr1Sd0jtW4Ge1pAA==",
-      "cpu": [
-        "arm64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "darwin"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@esbuild/darwin-x64": {
-      "version": "0.25.6",
-      "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.25.6.tgz",
-      "integrity": "sha512-GfXs5kry/TkGM2vKqK2oyiLFygJRqKVhawu3+DOCk7OxLy/6jYkWXhlHwOoTb0WqGnWGAS7sooxbZowy+pK9Yg==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "darwin"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@esbuild/freebsd-arm64": {
-      "version": "0.25.6",
-      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.25.6.tgz",
-      "integrity": "sha512-aoLF2c3OvDn2XDTRvn8hN6DRzVVpDlj2B/F66clWd/FHLiHaG3aVZjxQX2DYphA5y/evbdGvC6Us13tvyt4pWg==",
-      "cpu": [
-        "arm64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "freebsd"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@esbuild/freebsd-x64": {
-      "version": "0.25.6",
-      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.25.6.tgz",
-      "integrity": "sha512-2SkqTjTSo2dYi/jzFbU9Plt1vk0+nNg8YC8rOXXea+iA3hfNJWebKYPs3xnOUf9+ZWhKAaxnQNUf2X9LOpeiMQ==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "freebsd"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@esbuild/linux-arm": {
-      "version": "0.25.6",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.25.6.tgz",
-      "integrity": "sha512-SZHQlzvqv4Du5PrKE2faN0qlbsaW/3QQfUUc6yO2EjFcA83xnwm91UbEEVx4ApZ9Z5oG8Bxz4qPE+HFwtVcfyw==",
-      "cpu": [
-        "arm"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@esbuild/linux-arm64": {
-      "version": "0.25.6",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.25.6.tgz",
-      "integrity": "sha512-b967hU0gqKd9Drsh/UuAm21Khpoh6mPBSgz8mKRq4P5mVK8bpA+hQzmm/ZwGVULSNBzKdZPQBRT3+WuVavcWsQ==",
-      "cpu": [
-        "arm64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@esbuild/linux-ia32": {
-      "version": "0.25.6",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.25.6.tgz",
-      "integrity": "sha512-aHWdQ2AAltRkLPOsKdi3xv0mZ8fUGPdlKEjIEhxCPm5yKEThcUjHpWB1idN74lfXGnZ5SULQSgtr5Qos5B0bPw==",
-      "cpu": [
-        "ia32"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@esbuild/linux-loong64": {
-      "version": "0.25.6",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.25.6.tgz",
-      "integrity": "sha512-VgKCsHdXRSQ7E1+QXGdRPlQ/e08bN6WMQb27/TMfV+vPjjTImuT9PmLXupRlC90S1JeNNW5lzkAEO/McKeJ2yg==",
-      "cpu": [
-        "loong64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@esbuild/linux-mips64el": {
-      "version": "0.25.6",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.25.6.tgz",
-      "integrity": "sha512-WViNlpivRKT9/py3kCmkHnn44GkGXVdXfdc4drNmRl15zVQ2+D2uFwdlGh6IuK5AAnGTo2qPB1Djppj+t78rzw==",
-      "cpu": [
-        "mips64el"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@esbuild/linux-ppc64": {
-      "version": "0.25.6",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.25.6.tgz",
-      "integrity": "sha512-wyYKZ9NTdmAMb5730I38lBqVu6cKl4ZfYXIs31Baf8aoOtB4xSGi3THmDYt4BTFHk7/EcVixkOV2uZfwU3Q2Jw==",
-      "cpu": [
-        "ppc64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@esbuild/linux-riscv64": {
-      "version": "0.25.6",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.25.6.tgz",
-      "integrity": "sha512-KZh7bAGGcrinEj4qzilJ4hqTY3Dg2U82c8bv+e1xqNqZCrCyc+TL9AUEn5WGKDzm3CfC5RODE/qc96OcbIe33w==",
-      "cpu": [
-        "riscv64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@esbuild/linux-s390x": {
-      "version": "0.25.6",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.25.6.tgz",
-      "integrity": "sha512-9N1LsTwAuE9oj6lHMyyAM+ucxGiVnEqUdp4v7IaMmrwb06ZTEVCIs3oPPplVsnjPfyjmxwHxHMF8b6vzUVAUGw==",
-      "cpu": [
-        "s390x"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@esbuild/linux-x64": {
-      "version": "0.25.6",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.25.6.tgz",
-      "integrity": "sha512-A6bJB41b4lKFWRKNrWoP2LHsjVzNiaurf7wyj/XtFNTsnPuxwEBWHLty+ZE0dWBKuSK1fvKgrKaNjBS7qbFKig==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@esbuild/netbsd-arm64": {
-      "version": "0.25.6",
-      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-arm64/-/netbsd-arm64-0.25.6.tgz",
-      "integrity": "sha512-IjA+DcwoVpjEvyxZddDqBY+uJ2Snc6duLpjmkXm/v4xuS3H+3FkLZlDm9ZsAbF9rsfP3zeA0/ArNDORZgrxR/Q==",
-      "cpu": [
-        "arm64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "netbsd"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@esbuild/netbsd-x64": {
-      "version": "0.25.6",
-      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.25.6.tgz",
-      "integrity": "sha512-dUXuZr5WenIDlMHdMkvDc1FAu4xdWixTCRgP7RQLBOkkGgwuuzaGSYcOpW4jFxzpzL1ejb8yF620UxAqnBrR9g==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "netbsd"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@esbuild/openbsd-arm64": {
-      "version": "0.25.6",
-      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-arm64/-/openbsd-arm64-0.25.6.tgz",
-      "integrity": "sha512-l8ZCvXP0tbTJ3iaqdNf3pjaOSd5ex/e6/omLIQCVBLmHTlfXW3zAxQ4fnDmPLOB1x9xrcSi/xtCWFwCZRIaEwg==",
-      "cpu": [
-        "arm64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "openbsd"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@esbuild/openbsd-x64": {
-      "version": "0.25.6",
-      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.25.6.tgz",
-      "integrity": "sha512-hKrmDa0aOFOr71KQ/19JC7az1P0GWtCN1t2ahYAf4O007DHZt/dW8ym5+CUdJhQ/qkZmI1HAF8KkJbEFtCL7gw==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "openbsd"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@esbuild/openharmony-arm64": {
-      "version": "0.25.6",
-      "resolved": "https://registry.npmjs.org/@esbuild/openharmony-arm64/-/openharmony-arm64-0.25.6.tgz",
-      "integrity": "sha512-+SqBcAWoB1fYKmpWoQP4pGtx+pUUC//RNYhFdbcSA16617cchuryuhOCRpPsjCblKukAckWsV+aQ3UKT/RMPcA==",
-      "cpu": [
-        "arm64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "openharmony"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@esbuild/sunos-x64": {
-      "version": "0.25.6",
-      "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.25.6.tgz",
-      "integrity": "sha512-dyCGxv1/Br7MiSC42qinGL8KkG4kX0pEsdb0+TKhmJZgCUDBGmyo1/ArCjNGiOLiIAgdbWgmWgib4HoCi5t7kA==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "sunos"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@esbuild/win32-arm64": {
-      "version": "0.25.6",
-      "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.25.6.tgz",
-      "integrity": "sha512-42QOgcZeZOvXfsCBJF5Afw73t4veOId//XD3i+/9gSkhSV6Gk3VPlWncctI+JcOyERv85FUo7RxuxGy+z8A43Q==",
-      "cpu": [
-        "arm64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "win32"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@esbuild/win32-ia32": {
-      "version": "0.25.6",
-      "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.25.6.tgz",
-      "integrity": "sha512-4AWhgXmDuYN7rJI6ORB+uU9DHLq/erBbuMoAuB4VWJTu5KtCgcKYPynF0YI1VkBNuEfjNlLrFr9KZPJzrtLkrQ==",
-      "cpu": [
-        "ia32"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "win32"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@esbuild/win32-x64": {
-      "version": "0.25.6",
-      "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.25.6.tgz",
-      "integrity": "sha512-NgJPHHbEpLQgDH2MjQu90pzW/5vvXIZ7KOnPyNBm92A6WgZ/7b6fJyUBjoumLqeOQQGqY2QjQxRo97ah4Sj0cA==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "win32"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@eslint-community/eslint-utils": {
-      "version": "4.7.0",
-      "resolved": "https://registry.npmjs.org/@eslint-community/eslint-utils/-/eslint-utils-4.7.0.tgz",
-      "integrity": "sha512-dyybb3AcajC7uha6CvhdVRJqaKyn7w2YKqKyAN37NKYgZT36w+iRb0Dymmc5qEJ549c/S31cMMSFd75bteCpCw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "eslint-visitor-keys": "^3.4.3"
-      },
-      "engines": {
-        "node": "^12.22.0 || ^14.17.0 || >=16.0.0"
-      },
-      "funding": {
-        "url": "https://opencollective.com/eslint"
-      },
-      "peerDependencies": {
-        "eslint": "^6.0.0 || ^7.0.0 || >=8.0.0"
-      }
-    },
-    "node_modules/@eslint-community/regexpp": {
-      "version": "4.12.1",
-      "resolved": "https://registry.npmjs.org/@eslint-community/regexpp/-/regexpp-4.12.1.tgz",
-      "integrity": "sha512-CCZCDJuduB9OUkFkY2IgppNZMi2lBQgD2qzwXkEia16cge2pijY/aXi96CJMquDMn3nJdlPV1A5KrJEXwfLNzQ==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": "^12.0.0 || ^14.0.0 || >=16.0.0"
-      }
-    },
-    "node_modules/@eslint/config-array": {
-      "version": "0.21.0",
-      "resolved": "https://registry.npmjs.org/@eslint/config-array/-/config-array-0.21.0.tgz",
-      "integrity": "sha512-ENIdc4iLu0d93HeYirvKmrzshzofPw6VkZRKQGe9Nv46ZnWUzcF1xV01dcvEg/1wXUR61OmmlSfyeyO7EvjLxQ==",
-      "dev": true,
-      "license": "Apache-2.0",
-      "dependencies": {
-        "@eslint/object-schema": "^2.1.6",
-        "debug": "^4.3.1",
-        "minimatch": "^3.1.2"
-      },
-      "engines": {
-        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
-      }
-    },
-    "node_modules/@eslint/config-array/node_modules/brace-expansion": {
-      "version": "1.1.12",
-      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.12.tgz",
-      "integrity": "sha512-9T9UjW3r0UW5c1Q7GTwllptXwhvYmEzFhzMfZ9H7FQWt+uZePjZPjBP/W1ZEyZ1twGWom5/56TF4lPcqjnDHcg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "balanced-match": "^1.0.0",
-        "concat-map": "0.0.1"
-      }
-    },
-    "node_modules/@eslint/config-array/node_modules/minimatch": {
-      "version": "3.1.2",
-      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz",
-      "integrity": "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==",
-      "dev": true,
-      "license": "ISC",
-      "dependencies": {
-        "brace-expansion": "^1.1.7"
-      },
-      "engines": {
-        "node": "*"
-      }
-    },
-    "node_modules/@eslint/config-helpers": {
-      "version": "0.3.0",
-      "resolved": "https://registry.npmjs.org/@eslint/config-helpers/-/config-helpers-0.3.0.tgz",
-      "integrity": "sha512-ViuymvFmcJi04qdZeDc2whTHryouGcDlaxPqarTD0ZE10ISpxGUVZGZDx4w01upyIynL3iu6IXH2bS1NhclQMw==",
-      "dev": true,
-      "license": "Apache-2.0",
-      "engines": {
-        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
-      }
-    },
-    "node_modules/@eslint/core": {
-      "version": "0.14.0",
-      "resolved": "https://registry.npmjs.org/@eslint/core/-/core-0.14.0.tgz",
-      "integrity": "sha512-qIbV0/JZr7iSDjqAc60IqbLdsj9GDt16xQtWD+B78d/HAlvysGdZZ6rpJHGAc2T0FQx1X6thsSPdnoiGKdNtdg==",
-      "dev": true,
-      "license": "Apache-2.0",
-      "dependencies": {
-        "@types/json-schema": "^7.0.15"
-      },
-      "engines": {
-        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
-      }
-    },
-    "node_modules/@eslint/eslintrc": {
-      "version": "3.3.1",
-      "resolved": "https://registry.npmjs.org/@eslint/eslintrc/-/eslintrc-3.3.1.tgz",
-      "integrity": "sha512-gtF186CXhIl1p4pJNGZw8Yc6RlshoePRvE0X91oPGb3vZ8pM3qOS9W9NGPat9LziaBV7XrJWGylNQXkGcnM3IQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "ajv": "^6.12.4",
-        "debug": "^4.3.2",
-        "espree": "^10.0.1",
-        "globals": "^14.0.0",
-        "ignore": "^5.2.0",
-        "import-fresh": "^3.2.1",
-        "js-yaml": "^4.1.0",
-        "minimatch": "^3.1.2",
-        "strip-json-comments": "^3.1.1"
-      },
-      "engines": {
-        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
-      },
-      "funding": {
-        "url": "https://opencollective.com/eslint"
-      }
-    },
-    "node_modules/@eslint/eslintrc/node_modules/brace-expansion": {
-      "version": "1.1.12",
-      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.12.tgz",
-      "integrity": "sha512-9T9UjW3r0UW5c1Q7GTwllptXwhvYmEzFhzMfZ9H7FQWt+uZePjZPjBP/W1ZEyZ1twGWom5/56TF4lPcqjnDHcg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "balanced-match": "^1.0.0",
-        "concat-map": "0.0.1"
-      }
-    },
-    "node_modules/@eslint/eslintrc/node_modules/ignore": {
-      "version": "5.3.2",
-      "resolved": "https://registry.npmjs.org/ignore/-/ignore-5.3.2.tgz",
-      "integrity": "sha512-hsBTNUqQTDwkWtcdYI2i06Y/nUBEsNEDJKjWdigLvegy8kDuJAS8uRlpkkcQpyEXL0Z/pjDy5HBmMjRCJ2gq+g==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 4"
-      }
-    },
-    "node_modules/@eslint/eslintrc/node_modules/minimatch": {
-      "version": "3.1.2",
-      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz",
-      "integrity": "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==",
-      "dev": true,
-      "license": "ISC",
-      "dependencies": {
-        "brace-expansion": "^1.1.7"
-      },
-      "engines": {
-        "node": "*"
-      }
-    },
-    "node_modules/@eslint/js": {
-      "version": "9.30.1",
-      "resolved": "https://registry.npmjs.org/@eslint/js/-/js-9.30.1.tgz",
-      "integrity": "sha512-zXhuECFlyep42KZUhWjfvsmXGX39W8K8LFb8AWXM9gSV9dQB+MrJGLKvW6Zw0Ggnbpw0VHTtrhFXYe3Gym18jg==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
-      },
-      "funding": {
-        "url": "https://eslint.org/donate"
-      }
-    },
-    "node_modules/@eslint/object-schema": {
-      "version": "2.1.6",
-      "resolved": "https://registry.npmjs.org/@eslint/object-schema/-/object-schema-2.1.6.tgz",
-      "integrity": "sha512-RBMg5FRL0I0gs51M/guSAj5/e14VQ4tpZnQNWwuDT66P14I43ItmPfIZRhO9fUVIPOAQXU47atlywZ/czoqFPA==",
-      "dev": true,
-      "license": "Apache-2.0",
-      "engines": {
-        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
-      }
-    },
-    "node_modules/@eslint/plugin-kit": {
-      "version": "0.3.3",
-      "resolved": "https://registry.npmjs.org/@eslint/plugin-kit/-/plugin-kit-0.3.3.tgz",
-      "integrity": "sha512-1+WqvgNMhmlAambTvT3KPtCl/Ibr68VldY2XY40SL1CE0ZXiakFR/cbTspaF5HsnpDMvcYYoJHfl4980NBjGag==",
-      "dev": true,
-      "license": "Apache-2.0",
-      "dependencies": {
-        "@eslint/core": "^0.15.1",
-        "levn": "^0.4.1"
-      },
-      "engines": {
-        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
-      }
-    },
-    "node_modules/@eslint/plugin-kit/node_modules/@eslint/core": {
-      "version": "0.15.1",
-      "resolved": "https://registry.npmjs.org/@eslint/core/-/core-0.15.1.tgz",
-      "integrity": "sha512-bkOp+iumZCCbt1K1CmWf0R9pM5yKpDv+ZXtvSyQpudrI9kuFLp+bM2WOPXImuD/ceQuaa8f5pj93Y7zyECIGNA==",
-      "dev": true,
-      "license": "Apache-2.0",
-      "dependencies": {
-        "@types/json-schema": "^7.0.15"
-      },
-      "engines": {
-        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
-      }
-    },
-    "node_modules/@humanfs/core": {
-      "version": "0.19.1",
-      "resolved": "https://registry.npmjs.org/@humanfs/core/-/core-0.19.1.tgz",
-      "integrity": "sha512-5DyQ4+1JEUzejeK1JGICcideyfUbGixgS9jNgex5nqkW+cY7WZhxBigmieN5Qnw9ZosSNVC9KQKyb+GUaGyKUA==",
-      "dev": true,
-      "license": "Apache-2.0",
-      "engines": {
-        "node": ">=18.18.0"
-      }
-    },
-    "node_modules/@humanfs/node": {
-      "version": "0.16.6",
-      "resolved": "https://registry.npmjs.org/@humanfs/node/-/node-0.16.6.tgz",
-      "integrity": "sha512-YuI2ZHQL78Q5HbhDiBA1X4LmYdXCKCMQIfw0pw7piHJwyREFebJUvrQN4cMssyES6x+vfUbx1CIpaQUKYdQZOw==",
-      "dev": true,
-      "license": "Apache-2.0",
-      "dependencies": {
-        "@humanfs/core": "^0.19.1",
-        "@humanwhocodes/retry": "^0.3.0"
-      },
-      "engines": {
-        "node": ">=18.18.0"
-      }
-    },
-    "node_modules/@humanfs/node/node_modules/@humanwhocodes/retry": {
-      "version": "0.3.1",
-      "resolved": "https://registry.npmjs.org/@humanwhocodes/retry/-/retry-0.3.1.tgz",
-      "integrity": "sha512-JBxkERygn7Bv/GbN5Rv8Ul6LVknS+5Bp6RgDC/O8gEBU/yeH5Ui5C/OlWrTb6qct7LjjfT6Re2NxB0ln0yYybA==",
-      "dev": true,
-      "license": "Apache-2.0",
-      "engines": {
-        "node": ">=18.18"
-      },
-      "funding": {
-        "type": "github",
-        "url": "https://github.com/sponsors/nzakas"
-      }
-    },
-    "node_modules/@humanwhocodes/module-importer": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/@humanwhocodes/module-importer/-/module-importer-1.0.1.tgz",
-      "integrity": "sha512-bxveV4V8v5Yb4ncFTT3rPSgZBOpCkjfK0y4oVVVJwIuDVBRMDXrPyXRL988i5ap9m9bnyEEjWfm5WkBmtffLfA==",
-      "dev": true,
-      "license": "Apache-2.0",
-      "engines": {
-        "node": ">=12.22"
-      },
-      "funding": {
-        "type": "github",
-        "url": "https://github.com/sponsors/nzakas"
-      }
-    },
-    "node_modules/@humanwhocodes/retry": {
-      "version": "0.4.3",
-      "resolved": "https://registry.npmjs.org/@humanwhocodes/retry/-/retry-0.4.3.tgz",
-      "integrity": "sha512-bV0Tgo9K4hfPCek+aMAn81RppFKv2ySDQeMoSZuvTASywNTnVJCArCZE2FWqpvIatKu7VMRLWlR1EazvVhDyhQ==",
-      "dev": true,
-      "license": "Apache-2.0",
-      "engines": {
-        "node": ">=18.18"
-      },
-      "funding": {
-        "type": "github",
-        "url": "https://github.com/sponsors/nzakas"
-      }
-    },
-    "node_modules/@modelcontextprotocol/sdk": {
-      "version": "1.15.1",
-      "resolved": "https://registry.npmjs.org/@modelcontextprotocol/sdk/-/sdk-1.15.1.tgz",
-      "integrity": "sha512-W/XlN9c528yYn+9MQkVjxiTPgPxoxt+oczfjHBDsJx0+59+O7B75Zhsp0B16Xbwbz8ANISDajh6+V7nIcPMc5w==",
-      "license": "MIT",
-      "dependencies": {
-        "ajv": "^6.12.6",
-        "content-type": "^1.0.5",
-        "cors": "^2.8.5",
-        "cross-spawn": "^7.0.5",
-        "eventsource": "^3.0.2",
-        "eventsource-parser": "^3.0.0",
-        "express": "^5.0.1",
-        "express-rate-limit": "^7.5.0",
-        "pkce-challenge": "^5.0.0",
-        "raw-body": "^3.0.0",
-        "zod": "^3.23.8",
-        "zod-to-json-schema": "^3.24.1"
-      },
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@nodelib/fs.scandir": {
-      "version": "2.1.5",
-      "resolved": "https://registry.npmjs.org/@nodelib/fs.scandir/-/fs.scandir-2.1.5.tgz",
-      "integrity": "sha512-vq24Bq3ym5HEQm2NKCr3yXDwjc7vTsEThRDnkp2DK9p1uqLR+DHurm/NOTo0KG7HYHU7eppKZj3MyqYuMBf62g==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@nodelib/fs.stat": "2.0.5",
-        "run-parallel": "^1.1.9"
-      },
-      "engines": {
-        "node": ">= 8"
-      }
-    },
-    "node_modules/@nodelib/fs.stat": {
-      "version": "2.0.5",
-      "resolved": "https://registry.npmjs.org/@nodelib/fs.stat/-/fs.stat-2.0.5.tgz",
-      "integrity": "sha512-RkhPPp2zrqDAQA/2jNhnztcPAlv64XdhIp7a7454A5ovI7Bukxgt7MX7udwAu3zg1DcpPU0rz3VV1SeaqvY4+A==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 8"
-      }
-    },
-    "node_modules/@nodelib/fs.walk": {
-      "version": "1.2.8",
-      "resolved": "https://registry.npmjs.org/@nodelib/fs.walk/-/fs.walk-1.2.8.tgz",
-      "integrity": "sha512-oGB+UxlgWcgQkgwo8GcEGwemoTFt3FIO9ababBmaGwXIoBKZ+GTy0pP185beGg7Llih/NSHSV2XAs1lnznocSg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@nodelib/fs.scandir": "2.1.5",
-        "fastq": "^1.6.0"
-      },
-      "engines": {
-        "node": ">= 8"
-      }
-    },
-    "node_modules/@types/body-parser": {
-      "version": "1.19.6",
-      "resolved": "https://registry.npmjs.org/@types/body-parser/-/body-parser-1.19.6.tgz",
-      "integrity": "sha512-HLFeCYgz89uk22N5Qg3dvGvsv46B8GLvKKo1zKG4NybA8U2DiEO3w9lqGg29t/tfLRJpJ6iQxnVw4OnB7MoM9g==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@types/connect": "*",
-        "@types/node": "*"
-      }
-    },
-    "node_modules/@types/connect": {
-      "version": "3.4.38",
-      "resolved": "https://registry.npmjs.org/@types/connect/-/connect-3.4.38.tgz",
-      "integrity": "sha512-K6uROf1LD88uDQqJCktA4yzL1YYAK6NgfsI0v/mTgyPKWsX1CnJ0XPSDhViejru1GcRkLWb8RlzFYJRqGUbaug==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@types/node": "*"
-      }
-    },
-    "node_modules/@types/cors": {
-      "version": "2.8.19",
-      "resolved": "https://registry.npmjs.org/@types/cors/-/cors-2.8.19.tgz",
-      "integrity": "sha512-mFNylyeyqN93lfe/9CSxOGREz8cpzAhH+E93xJ4xWQf62V8sQ/24reV2nyzUWM6H6Xji+GGHpkbLe7pVoUEskg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@types/node": "*"
-      }
-    },
-    "node_modules/@types/estree": {
-      "version": "1.0.8",
-      "resolved": "https://registry.npmjs.org/@types/estree/-/estree-1.0.8.tgz",
-      "integrity": "sha512-dWHzHa2WqEXI/O1E9OjrocMTKJl2mSrEolh1Iomrv6U+JuNwaHXsXx9bLu5gG7BUWFIN0skIQJQ/L1rIex4X6w==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/@types/express": {
-      "version": "5.0.3",
-      "resolved": "https://registry.npmjs.org/@types/express/-/express-5.0.3.tgz",
-      "integrity": "sha512-wGA0NX93b19/dZC1J18tKWVIYWyyF2ZjT9vin/NRu0qzzvfVzWjs04iq2rQ3H65vCTQYlRqs3YHfY7zjdV+9Kw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@types/body-parser": "*",
-        "@types/express-serve-static-core": "^5.0.0",
-        "@types/serve-static": "*"
-      }
-    },
-    "node_modules/@types/express-serve-static-core": {
-      "version": "5.0.7",
-      "resolved": "https://registry.npmjs.org/@types/express-serve-static-core/-/express-serve-static-core-5.0.7.tgz",
-      "integrity": "sha512-R+33OsgWw7rOhD1emjU7dzCDHucJrgJXMA5PYCzJxVil0dsyx5iBEPHqpPfiKNJQb7lZ1vxwoLR4Z87bBUpeGQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@types/node": "*",
-        "@types/qs": "*",
-        "@types/range-parser": "*",
-        "@types/send": "*"
-      }
-    },
-    "node_modules/@types/http-errors": {
-      "version": "2.0.5",
-      "resolved": "https://registry.npmjs.org/@types/http-errors/-/http-errors-2.0.5.tgz",
-      "integrity": "sha512-r8Tayk8HJnX0FztbZN7oVqGccWgw98T/0neJphO91KkmOzug1KkofZURD4UaD5uH8AqcFLfdPErnBod0u71/qg==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/@types/json-schema": {
-      "version": "7.0.15",
-      "resolved": "https://registry.npmjs.org/@types/json-schema/-/json-schema-7.0.15.tgz",
-      "integrity": "sha512-5+fP8P8MFNC+AyZCDxrB2pkZFPGzqQWUzpSeuuVLvm8VMcorNYavBqoFcxK8bQz4Qsbn4oUEEem4wDLfcysGHA==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/@types/mime": {
-      "version": "1.3.5",
-      "resolved": "https://registry.npmjs.org/@types/mime/-/mime-1.3.5.tgz",
-      "integrity": "sha512-/pyBZWSLD2n0dcHE3hq8s8ZvcETHtEuF+3E7XVt0Ig2nvsVQXdghHVcEkIWjy9A0wKfTn97a/PSDYohKIlnP/w==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/@types/node": {
-      "version": "20.19.7",
-      "resolved": "https://registry.npmjs.org/@types/node/-/node-20.19.7.tgz",
-      "integrity": "sha512-1GM9z6BJOv86qkPvzh2i6VW5+VVrXxCLknfmTkWEqz+6DqosiY28XUWCTmBcJ0ACzKqx/iwdIREfo1fwExIlkA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "undici-types": "~6.21.0"
-      }
-    },
-    "node_modules/@types/qs": {
-      "version": "6.14.0",
-      "resolved": "https://registry.npmjs.org/@types/qs/-/qs-6.14.0.tgz",
-      "integrity": "sha512-eOunJqu0K1923aExK6y8p6fsihYEn/BYuQ4g0CxAAgFc4b/ZLN4CrsRZ55srTdqoiLzU2B2evC+apEIxprEzkQ==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/@types/range-parser": {
-      "version": "1.2.7",
-      "resolved": "https://registry.npmjs.org/@types/range-parser/-/range-parser-1.2.7.tgz",
-      "integrity": "sha512-hKormJbkJqzQGhziax5PItDUTMAM9uE2XXQmM37dyd4hVM+5aVl7oVxMVUiVQn2oCQFN/LKCZdvSM0pFRqbSmQ==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/@types/send": {
-      "version": "0.17.5",
-      "resolved": "https://registry.npmjs.org/@types/send/-/send-0.17.5.tgz",
-      "integrity": "sha512-z6F2D3cOStZvuk2SaP6YrwkNO65iTZcwA2ZkSABegdkAh/lf+Aa/YQndZVfmEXT5vgAp6zv06VQ3ejSVjAny4w==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@types/mime": "^1",
-        "@types/node": "*"
-      }
-    },
-    "node_modules/@types/serve-static": {
-      "version": "1.15.8",
-      "resolved": "https://registry.npmjs.org/@types/serve-static/-/serve-static-1.15.8.tgz",
-      "integrity": "sha512-roei0UY3LhpOJvjbIP6ZZFngyLKl5dskOtDhxY5THRSpO+ZI+nzJ+m5yUMzGrp89YRa7lvknKkMYjqQFGwA7Sg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@types/http-errors": "*",
-        "@types/node": "*",
-        "@types/send": "*"
-      }
-    },
-    "node_modules/@types/vscode": {
-      "version": "1.101.0",
-      "resolved": "https://registry.npmjs.org/@types/vscode/-/vscode-1.101.0.tgz",
-      "integrity": "sha512-ZWf0IWa+NGegdW3iU42AcDTFHWW7fApLdkdnBqwYEtHVIBGbTu0ZNQKP/kX3Ds/uMJXIMQNAojHR4vexCEEz5Q==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/@typescript-eslint/eslint-plugin": {
-      "version": "8.36.0",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/eslint-plugin/-/eslint-plugin-8.36.0.tgz",
-      "integrity": "sha512-lZNihHUVB6ZZiPBNgOQGSxUASI7UJWhT8nHyUGCnaQ28XFCw98IfrMCG3rUl1uwUWoAvodJQby2KTs79UTcrAg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@eslint-community/regexpp": "^4.10.0",
-        "@typescript-eslint/scope-manager": "8.36.0",
-        "@typescript-eslint/type-utils": "8.36.0",
-        "@typescript-eslint/utils": "8.36.0",
-        "@typescript-eslint/visitor-keys": "8.36.0",
-        "graphemer": "^1.4.0",
-        "ignore": "^7.0.0",
-        "natural-compare": "^1.4.0",
-        "ts-api-utils": "^2.1.0"
-      },
-      "engines": {
-        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
-      },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/typescript-eslint"
-      },
-      "peerDependencies": {
-        "@typescript-eslint/parser": "^8.36.0",
-        "eslint": "^8.57.0 || ^9.0.0",
-        "typescript": ">=4.8.4 <5.9.0"
-      }
-    },
-    "node_modules/@typescript-eslint/parser": {
-      "version": "8.36.0",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/parser/-/parser-8.36.0.tgz",
-      "integrity": "sha512-FuYgkHwZLuPbZjQHzJXrtXreJdFMKl16BFYyRrLxDhWr6Qr7Kbcu2s1Yhu8tsiMXw1S0W1pjfFfYEt+R604s+Q==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@typescript-eslint/scope-manager": "8.36.0",
-        "@typescript-eslint/types": "8.36.0",
-        "@typescript-eslint/typescript-estree": "8.36.0",
-        "@typescript-eslint/visitor-keys": "8.36.0",
-        "debug": "^4.3.4"
-      },
-      "engines": {
-        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
-      },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/typescript-eslint"
-      },
-      "peerDependencies": {
-        "eslint": "^8.57.0 || ^9.0.0",
-        "typescript": ">=4.8.4 <5.9.0"
-      }
-    },
-    "node_modules/@typescript-eslint/project-service": {
-      "version": "8.36.0",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/project-service/-/project-service-8.36.0.tgz",
-      "integrity": "sha512-JAhQFIABkWccQYeLMrHadu/fhpzmSQ1F1KXkpzqiVxA/iYI6UnRt2trqXHt1sYEcw1mxLnB9rKMsOxXPxowN/g==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@typescript-eslint/tsconfig-utils": "^8.36.0",
-        "@typescript-eslint/types": "^8.36.0",
-        "debug": "^4.3.4"
-      },
-      "engines": {
-        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
-      },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/typescript-eslint"
-      },
-      "peerDependencies": {
-        "typescript": ">=4.8.4 <5.9.0"
-      }
-    },
-    "node_modules/@typescript-eslint/scope-manager": {
-      "version": "8.36.0",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/scope-manager/-/scope-manager-8.36.0.tgz",
-      "integrity": "sha512-wCnapIKnDkN62fYtTGv2+RY8FlnBYA3tNm0fm91kc2BjPhV2vIjwwozJ7LToaLAyb1ca8BxrS7vT+Pvvf7RvqA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@typescript-eslint/types": "8.36.0",
-        "@typescript-eslint/visitor-keys": "8.36.0"
-      },
-      "engines": {
-        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
-      },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/typescript-eslint"
-      }
-    },
-    "node_modules/@typescript-eslint/tsconfig-utils": {
-      "version": "8.36.0",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/tsconfig-utils/-/tsconfig-utils-8.36.0.tgz",
-      "integrity": "sha512-Nhh3TIEgN18mNbdXpd5Q8mSCBnrZQeY9V7Ca3dqYvNDStNIGRmJA6dmrIPMJ0kow3C7gcQbpsG2rPzy1Ks/AnA==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
-      },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/typescript-eslint"
-      },
-      "peerDependencies": {
-        "typescript": ">=4.8.4 <5.9.0"
-      }
-    },
-    "node_modules/@typescript-eslint/type-utils": {
-      "version": "8.36.0",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/type-utils/-/type-utils-8.36.0.tgz",
-      "integrity": "sha512-5aaGYG8cVDd6cxfk/ynpYzxBRZJk7w/ymto6uiyUFtdCozQIsQWh7M28/6r57Fwkbweng8qAzoMCPwSJfWlmsg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@typescript-eslint/typescript-estree": "8.36.0",
-        "@typescript-eslint/utils": "8.36.0",
-        "debug": "^4.3.4",
-        "ts-api-utils": "^2.1.0"
-      },
-      "engines": {
-        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
-      },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/typescript-eslint"
-      },
-      "peerDependencies": {
-        "eslint": "^8.57.0 || ^9.0.0",
-        "typescript": ">=4.8.4 <5.9.0"
-      }
-    },
-    "node_modules/@typescript-eslint/types": {
-      "version": "8.36.0",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/types/-/types-8.36.0.tgz",
-      "integrity": "sha512-xGms6l5cTJKQPZOKM75Dl9yBfNdGeLRsIyufewnxT4vZTrjC0ImQT4fj8QmtJK84F58uSh5HVBSANwcfiXxABQ==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
-      },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/typescript-eslint"
-      }
-    },
-    "node_modules/@typescript-eslint/typescript-estree": {
-      "version": "8.36.0",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/typescript-estree/-/typescript-estree-8.36.0.tgz",
-      "integrity": "sha512-JaS8bDVrfVJX4av0jLpe4ye0BpAaUW7+tnS4Y4ETa3q7NoZgzYbN9zDQTJ8kPb5fQ4n0hliAt9tA4Pfs2zA2Hg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@typescript-eslint/project-service": "8.36.0",
-        "@typescript-eslint/tsconfig-utils": "8.36.0",
-        "@typescript-eslint/types": "8.36.0",
-        "@typescript-eslint/visitor-keys": "8.36.0",
-        "debug": "^4.3.4",
-        "fast-glob": "^3.3.2",
-        "is-glob": "^4.0.3",
-        "minimatch": "^9.0.4",
-        "semver": "^7.6.0",
-        "ts-api-utils": "^2.1.0"
-      },
-      "engines": {
-        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
-      },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/typescript-eslint"
-      },
-      "peerDependencies": {
-        "typescript": ">=4.8.4 <5.9.0"
-      }
-    },
-    "node_modules/@typescript-eslint/utils": {
-      "version": "8.36.0",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/utils/-/utils-8.36.0.tgz",
-      "integrity": "sha512-VOqmHu42aEMT+P2qYjylw6zP/3E/HvptRwdn/PZxyV27KhZg2IOszXod4NcXisWzPAGSS4trE/g4moNj6XmH2g==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@eslint-community/eslint-utils": "^4.7.0",
-        "@typescript-eslint/scope-manager": "8.36.0",
-        "@typescript-eslint/types": "8.36.0",
-        "@typescript-eslint/typescript-estree": "8.36.0"
-      },
-      "engines": {
-        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
-      },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/typescript-eslint"
-      },
-      "peerDependencies": {
-        "eslint": "^8.57.0 || ^9.0.0",
-        "typescript": ">=4.8.4 <5.9.0"
-      }
-    },
-    "node_modules/@typescript-eslint/visitor-keys": {
-      "version": "8.36.0",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/visitor-keys/-/visitor-keys-8.36.0.tgz",
-      "integrity": "sha512-vZrhV2lRPWDuGoxcmrzRZyxAggPL+qp3WzUrlZD+slFueDiYHxeBa34dUXPuC0RmGKzl4lS5kFJYvKCq9cnNDA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@typescript-eslint/types": "8.36.0",
-        "eslint-visitor-keys": "^4.2.1"
-      },
-      "engines": {
-        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
-      },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/typescript-eslint"
-      }
-    },
-    "node_modules/@typescript-eslint/visitor-keys/node_modules/eslint-visitor-keys": {
-      "version": "4.2.1",
-      "resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-4.2.1.tgz",
-      "integrity": "sha512-Uhdk5sfqcee/9H/rCOJikYz67o0a2Tw2hGRPOG2Y1R2dg7brRe1uG0yaNQDHu+TO/uQPF/5eCapvYSmHUjt7JQ==",
-      "dev": true,
-      "license": "Apache-2.0",
-      "engines": {
-        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
-      },
-      "funding": {
-        "url": "https://opencollective.com/eslint"
-      }
-    },
-    "node_modules/accepts": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/accepts/-/accepts-2.0.0.tgz",
-      "integrity": "sha512-5cvg6CtKwfgdmVqY1WIiXKc3Q1bkRqGLi+2W/6ao+6Y7gu/RCwRuAhGEzh5B4KlszSuTLgZYuqFqo5bImjNKng==",
-      "license": "MIT",
-      "dependencies": {
-        "mime-types": "^3.0.0",
-        "negotiator": "^1.0.0"
-      },
-      "engines": {
-        "node": ">= 0.6"
-      }
-    },
-    "node_modules/acorn": {
-      "version": "8.15.0",
-      "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.15.0.tgz",
-      "integrity": "sha512-NZyJarBfL7nWwIq+FDL6Zp/yHEhePMNnnJ0y3qfieCrmNvYct8uvtiV41UvlSe6apAfk0fY1FbWx+NwfmpvtTg==",
-      "dev": true,
-      "license": "MIT",
-      "bin": {
-        "acorn": "bin/acorn"
-      },
-      "engines": {
-        "node": ">=0.4.0"
-      }
-    },
-    "node_modules/acorn-jsx": {
-      "version": "5.3.2",
-      "resolved": "https://registry.npmjs.org/acorn-jsx/-/acorn-jsx-5.3.2.tgz",
-      "integrity": "sha512-rq9s+JNhf0IChjtDXxllJ7g41oZk5SlXtp0LHwyA5cejwn7vKmKp4pPri6YEePv2PU65sAsegbXtIinmDFDXgQ==",
-      "dev": true,
-      "license": "MIT",
-      "peerDependencies": {
-        "acorn": "^6.0.0 || ^7.0.0 || ^8.0.0"
-      }
-    },
-    "node_modules/ajv": {
-      "version": "6.12.6",
-      "resolved": "https://registry.npmjs.org/ajv/-/ajv-6.12.6.tgz",
-      "integrity": "sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g==",
-      "license": "MIT",
-      "dependencies": {
-        "fast-deep-equal": "^3.1.1",
-        "fast-json-stable-stringify": "^2.0.0",
-        "json-schema-traverse": "^0.4.1",
-        "uri-js": "^4.2.2"
-      },
-      "funding": {
-        "type": "github",
-        "url": "https://github.com/sponsors/epoberezkin"
-      }
-    },
-    "node_modules/ansi-styles": {
-      "version": "4.3.0",
-      "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz",
-      "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "color-convert": "^2.0.1"
-      },
-      "engines": {
-        "node": ">=8"
-      },
-      "funding": {
-        "url": "https://github.com/chalk/ansi-styles?sponsor=1"
-      }
-    },
-    "node_modules/argparse": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/argparse/-/argparse-2.0.1.tgz",
-      "integrity": "sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==",
-      "dev": true,
-      "license": "Python-2.0"
-    },
-    "node_modules/array-buffer-byte-length": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/array-buffer-byte-length/-/array-buffer-byte-length-1.0.2.tgz",
-      "integrity": "sha512-LHE+8BuR7RYGDKvnrmcuSq3tDcKv9OFEXQt/HpbZhY7V6h0zlUXutnAD82GiFx9rdieCMjkvtcsPqBwgUl1Iiw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "call-bound": "^1.0.3",
-        "is-array-buffer": "^3.0.5"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/arraybuffer.prototype.slice": {
-      "version": "1.0.4",
-      "resolved": "https://registry.npmjs.org/arraybuffer.prototype.slice/-/arraybuffer.prototype.slice-1.0.4.tgz",
-      "integrity": "sha512-BNoCY6SXXPQ7gF2opIP4GBE+Xw7U+pHMYKuzjgCN3GwiaIR09UUeKfheyIry77QtrCBlC0KK0q5/TER/tYh3PQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "array-buffer-byte-length": "^1.0.1",
-        "call-bind": "^1.0.8",
-        "define-properties": "^1.2.1",
-        "es-abstract": "^1.23.5",
-        "es-errors": "^1.3.0",
-        "get-intrinsic": "^1.2.6",
-        "is-array-buffer": "^3.0.4"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/async-function": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/async-function/-/async-function-1.0.0.tgz",
-      "integrity": "sha512-hsU18Ae8CDTR6Kgu9DYf0EbCr/a5iGL0rytQDobUcdpYOKokk8LEjVphnXkDkgpi0wYVsqrXuP0bZxJaTqdgoA==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.4"
-      }
-    },
-    "node_modules/available-typed-arrays": {
-      "version": "1.0.7",
-      "resolved": "https://registry.npmjs.org/available-typed-arrays/-/available-typed-arrays-1.0.7.tgz",
-      "integrity": "sha512-wvUjBtSGN7+7SjNpq/9M2Tg350UZD3q62IFZLbRAR1bSMlCo1ZaeW+BJ+D090e4hIIZLBcTDWe4Mh4jvUDajzQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "possible-typed-array-names": "^1.0.0"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/balanced-match": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.2.tgz",
-      "integrity": "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/body-parser": {
-      "version": "2.2.0",
-      "resolved": "https://registry.npmjs.org/body-parser/-/body-parser-2.2.0.tgz",
-      "integrity": "sha512-02qvAaxv8tp7fBa/mw1ga98OGm+eCbqzJOKoRt70sLmfEEi+jyBYVTDGfCL/k06/4EMk/z01gCe7HoCH/f2LTg==",
-      "license": "MIT",
-      "dependencies": {
-        "bytes": "^3.1.2",
-        "content-type": "^1.0.5",
-        "debug": "^4.4.0",
-        "http-errors": "^2.0.0",
-        "iconv-lite": "^0.6.3",
-        "on-finished": "^2.4.1",
-        "qs": "^6.14.0",
-        "raw-body": "^3.0.0",
-        "type-is": "^2.0.0"
-      },
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/brace-expansion": {
-      "version": "2.0.2",
-      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.0.2.tgz",
-      "integrity": "sha512-Jt0vHyM+jmUBqojB7E1NIYadt0vI0Qxjxd2TErW94wDz+E2LAm5vKMXXwg6ZZBTHPuUlDgQHKXvjGBdfcF1ZDQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "balanced-match": "^1.0.0"
-      }
-    },
-    "node_modules/braces": {
-      "version": "3.0.3",
-      "resolved": "https://registry.npmjs.org/braces/-/braces-3.0.3.tgz",
-      "integrity": "sha512-yQbXgO/OSZVD2IsiLlro+7Hf6Q18EJrKSEsdoMzKePKXct3gvD8oLcOQdIzGupr5Fj+EDe8gO/lxc1BzfMpxvA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "fill-range": "^7.1.1"
-      },
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/bytes": {
-      "version": "3.1.2",
-      "resolved": "https://registry.npmjs.org/bytes/-/bytes-3.1.2.tgz",
-      "integrity": "sha512-/Nf7TyzTx6S3yRJObOAV7956r8cr2+Oj8AC5dt8wSP3BQAoeX58NoHyCU8P8zGkNXStjTSi6fzO6F0pBdcYbEg==",
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.8"
-      }
-    },
-    "node_modules/call-bind": {
-      "version": "1.0.8",
-      "resolved": "https://registry.npmjs.org/call-bind/-/call-bind-1.0.8.tgz",
-      "integrity": "sha512-oKlSFMcMwpUg2ednkhQ454wfWiU/ul3CkJe/PEHcTKuiX6RpbehUiFMXu13HalGZxfUwCQzZG747YXBn1im9ww==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "call-bind-apply-helpers": "^1.0.0",
-        "es-define-property": "^1.0.0",
-        "get-intrinsic": "^1.2.4",
-        "set-function-length": "^1.2.2"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/call-bind-apply-helpers": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/call-bind-apply-helpers/-/call-bind-apply-helpers-1.0.2.tgz",
-      "integrity": "sha512-Sp1ablJ0ivDkSzjcaJdxEunN5/XvksFJ2sMBFfq6x0ryhQV/2b/KwFe21cMpmHtPOSij8K99/wSfoEuTObmuMQ==",
-      "license": "MIT",
-      "dependencies": {
-        "es-errors": "^1.3.0",
-        "function-bind": "^1.1.2"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      }
-    },
-    "node_modules/call-bound": {
-      "version": "1.0.4",
-      "resolved": "https://registry.npmjs.org/call-bound/-/call-bound-1.0.4.tgz",
-      "integrity": "sha512-+ys997U96po4Kx/ABpBCqhA9EuxJaQWDQg7295H4hBphv3IZg0boBKuwYpt4YXp6MZ5AmZQnU/tyMTlRpaSejg==",
-      "license": "MIT",
-      "dependencies": {
-        "call-bind-apply-helpers": "^1.0.2",
-        "get-intrinsic": "^1.3.0"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/callsites": {
-      "version": "3.1.0",
-      "resolved": "https://registry.npmjs.org/callsites/-/callsites-3.1.0.tgz",
-      "integrity": "sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=6"
-      }
-    },
-    "node_modules/chalk": {
-      "version": "4.1.2",
-      "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz",
-      "integrity": "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "ansi-styles": "^4.1.0",
-        "supports-color": "^7.1.0"
-      },
-      "engines": {
-        "node": ">=10"
-      },
-      "funding": {
-        "url": "https://github.com/chalk/chalk?sponsor=1"
-      }
-    },
-    "node_modules/chalk/node_modules/supports-color": {
-      "version": "7.2.0",
-      "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz",
-      "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "has-flag": "^4.0.0"
-      },
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/color-convert": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz",
-      "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "color-name": "~1.1.4"
-      },
-      "engines": {
-        "node": ">=7.0.0"
-      }
-    },
-    "node_modules/color-name": {
-      "version": "1.1.4",
-      "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz",
-      "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/concat-map": {
-      "version": "0.0.1",
-      "resolved": "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz",
-      "integrity": "sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/content-disposition": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/content-disposition/-/content-disposition-1.0.0.tgz",
-      "integrity": "sha512-Au9nRL8VNUut/XSzbQA38+M78dzP4D+eqg3gfJHMIHHYa3bg067xj1KxMUWj+VULbiZMowKngFFbKczUrNJ1mg==",
-      "license": "MIT",
-      "dependencies": {
-        "safe-buffer": "5.2.1"
-      },
-      "engines": {
-        "node": ">= 0.6"
-      }
-    },
-    "node_modules/content-disposition/node_modules/safe-buffer": {
-      "version": "5.2.1",
-      "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.2.1.tgz",
-      "integrity": "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==",
-      "funding": [
-        {
-          "type": "github",
-          "url": "https://github.com/sponsors/feross"
-        },
-        {
-          "type": "patreon",
-          "url": "https://www.patreon.com/feross"
-        },
-        {
-          "type": "consulting",
-          "url": "https://feross.org/support"
-        }
-      ],
-      "license": "MIT"
-    },
-    "node_modules/content-type": {
-      "version": "1.0.5",
-      "resolved": "https://registry.npmjs.org/content-type/-/content-type-1.0.5.tgz",
-      "integrity": "sha512-nTjqfcBFEipKdXCv4YDQWCfmcLZKm81ldF0pAopTvyrFGVbcR6P/VAAd5G7N+0tTr8QqiU0tFadD6FK4NtJwOA==",
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.6"
-      }
-    },
-    "node_modules/cookie": {
-      "version": "0.7.2",
-      "resolved": "https://registry.npmjs.org/cookie/-/cookie-0.7.2.tgz",
-      "integrity": "sha512-yki5XnKuf750l50uGTllt6kKILY4nQ1eNIQatoXEByZ5dWgnKqbnqmTrBE5B4N7lrMJKQ2ytWMiTO2o0v6Ew/w==",
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.6"
-      }
-    },
-    "node_modules/cookie-signature": {
-      "version": "1.2.2",
-      "resolved": "https://registry.npmjs.org/cookie-signature/-/cookie-signature-1.2.2.tgz",
-      "integrity": "sha512-D76uU73ulSXrD1UXF4KE2TMxVVwhsnCgfAyTg9k8P6KGZjlXKrOLe4dJQKI3Bxi5wjesZoFXJWElNWBjPZMbhg==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=6.6.0"
-      }
-    },
-    "node_modules/cors": {
-      "version": "2.8.5",
-      "resolved": "https://registry.npmjs.org/cors/-/cors-2.8.5.tgz",
-      "integrity": "sha512-KIHbLJqu73RGr/hnbrO9uBeixNGuvSQjul/jdFvS/KFSIH1hWVd1ng7zOHx+YrEfInLG7q4n6GHQ9cDtxv/P6g==",
-      "license": "MIT",
-      "dependencies": {
-        "object-assign": "^4",
-        "vary": "^1"
-      },
-      "engines": {
-        "node": ">= 0.10"
-      }
-    },
-    "node_modules/cross-spawn": {
-      "version": "7.0.6",
-      "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-7.0.6.tgz",
-      "integrity": "sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA==",
-      "license": "MIT",
-      "dependencies": {
-        "path-key": "^3.1.0",
-        "shebang-command": "^2.0.0",
-        "which": "^2.0.1"
-      },
-      "engines": {
-        "node": ">= 8"
-      }
-    },
-    "node_modules/data-view-buffer": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/data-view-buffer/-/data-view-buffer-1.0.2.tgz",
-      "integrity": "sha512-EmKO5V3OLXh1rtK2wgXRansaK1/mtVdTUEiEI0W8RkvgT05kfxaH29PliLnpLP73yYO6142Q72QNa8Wx/A5CqQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "call-bound": "^1.0.3",
-        "es-errors": "^1.3.0",
-        "is-data-view": "^1.0.2"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/data-view-byte-length": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/data-view-byte-length/-/data-view-byte-length-1.0.2.tgz",
-      "integrity": "sha512-tuhGbE6CfTM9+5ANGf+oQb72Ky/0+s3xKUpHvShfiz2RxMFgFPjsXuRLBVMtvMs15awe45SRb83D6wH4ew6wlQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "call-bound": "^1.0.3",
-        "es-errors": "^1.3.0",
-        "is-data-view": "^1.0.2"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/inspect-js"
-      }
-    },
-    "node_modules/data-view-byte-offset": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/data-view-byte-offset/-/data-view-byte-offset-1.0.1.tgz",
-      "integrity": "sha512-BS8PfmtDGnrgYdOonGZQdLZslWIeCGFP9tpan0hi1Co2Zr2NKADsvGYA8XxuG/4UWgJ6Cjtv+YJnB6MM69QGlQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "call-bound": "^1.0.2",
-        "es-errors": "^1.3.0",
-        "is-data-view": "^1.0.1"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/debug": {
-      "version": "4.4.1",
-      "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.1.tgz",
-      "integrity": "sha512-KcKCqiftBJcZr++7ykoDIEwSa3XWowTfNPo92BYxjXiyYEVrUQh2aLyhxBCwww+heortUFxEJYcRzosstTEBYQ==",
-      "license": "MIT",
-      "dependencies": {
-        "ms": "^2.1.3"
-      },
-      "engines": {
-        "node": ">=6.0"
-      },
-      "peerDependenciesMeta": {
-        "supports-color": {
-          "optional": true
-        }
-      }
-    },
-    "node_modules/deep-is": {
-      "version": "0.1.4",
-      "resolved": "https://registry.npmjs.org/deep-is/-/deep-is-0.1.4.tgz",
-      "integrity": "sha512-oIPzksmTg4/MriiaYGO+okXDT7ztn/w3Eptv/+gSIdMdKsJo0u4CfYNFJPy+4SKMuCqGw2wxnA+URMg3t8a/bQ==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/define-data-property": {
-      "version": "1.1.4",
-      "resolved": "https://registry.npmjs.org/define-data-property/-/define-data-property-1.1.4.tgz",
-      "integrity": "sha512-rBMvIzlpA8v6E+SJZoo++HAYqsLrkg7MSfIinMPFhmkorw7X+dOXVJQs+QT69zGkzMyfDnIMN2Wid1+NbL3T+A==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "es-define-property": "^1.0.0",
-        "es-errors": "^1.3.0",
-        "gopd": "^1.0.1"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/define-properties": {
-      "version": "1.2.1",
-      "resolved": "https://registry.npmjs.org/define-properties/-/define-properties-1.2.1.tgz",
-      "integrity": "sha512-8QmQKqEASLd5nx0U1B1okLElbUuuttJ/AnYmRXbbbGDWh6uS208EjD4Xqq/I9wK7u0v6O08XhTWnt5XtEbR6Dg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "define-data-property": "^1.0.1",
-        "has-property-descriptors": "^1.0.0",
-        "object-keys": "^1.1.1"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/depd": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/depd/-/depd-2.0.0.tgz",
-      "integrity": "sha512-g7nH6P6dyDioJogAAGprGpCtVImJhpPk/roCzdb3fIh61/s/nPsfR6onyMwkCAR/OlC3yBC0lESvUoQEAssIrw==",
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.8"
-      }
-    },
-    "node_modules/dunder-proto": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/dunder-proto/-/dunder-proto-1.0.1.tgz",
-      "integrity": "sha512-KIN/nDJBQRcXw0MLVhZE9iQHmG68qAVIBg9CqmUYjmQIhgij9U5MFvrqkUL5FbtyyzZuOeOt0zdeRe4UY7ct+A==",
-      "license": "MIT",
-      "dependencies": {
-        "call-bind-apply-helpers": "^1.0.1",
-        "es-errors": "^1.3.0",
-        "gopd": "^1.2.0"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      }
-    },
-    "node_modules/ee-first": {
-      "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/ee-first/-/ee-first-1.1.1.tgz",
-      "integrity": "sha512-WMwm9LhRUo+WUaRN+vRuETqG89IgZphVSNkdFgeb6sS/E4OrDIN7t48CAewSHXc6C8lefD8KKfr5vY61brQlow==",
-      "license": "MIT"
-    },
-    "node_modules/encodeurl": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/encodeurl/-/encodeurl-2.0.0.tgz",
-      "integrity": "sha512-Q0n9HRi4m6JuGIV1eFlmvJB7ZEVxu93IrMyiMsGC0lrMJMWzRgx6WGquyfQgZVb31vhGgXnfmPNNXmxnOkRBrg==",
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.8"
-      }
-    },
-    "node_modules/error-ex": {
-      "version": "1.3.2",
-      "resolved": "https://registry.npmjs.org/error-ex/-/error-ex-1.3.2.tgz",
-      "integrity": "sha512-7dFHNmqeFSEt2ZBsCriorKnn3Z2pj+fd9kmI6QoWw4//DL+icEBfc0U7qJCisqrTsKTjw4fNFy2pW9OqStD84g==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "is-arrayish": "^0.2.1"
-      }
-    },
-    "node_modules/es-abstract": {
-      "version": "1.24.0",
-      "resolved": "https://registry.npmjs.org/es-abstract/-/es-abstract-1.24.0.tgz",
-      "integrity": "sha512-WSzPgsdLtTcQwm4CROfS5ju2Wa1QQcVeT37jFjYzdFz1r9ahadC8B8/a4qxJxM+09F18iumCdRmlr96ZYkQvEg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "array-buffer-byte-length": "^1.0.2",
-        "arraybuffer.prototype.slice": "^1.0.4",
-        "available-typed-arrays": "^1.0.7",
-        "call-bind": "^1.0.8",
-        "call-bound": "^1.0.4",
-        "data-view-buffer": "^1.0.2",
-        "data-view-byte-length": "^1.0.2",
-        "data-view-byte-offset": "^1.0.1",
-        "es-define-property": "^1.0.1",
-        "es-errors": "^1.3.0",
-        "es-object-atoms": "^1.1.1",
-        "es-set-tostringtag": "^2.1.0",
-        "es-to-primitive": "^1.3.0",
-        "function.prototype.name": "^1.1.8",
-        "get-intrinsic": "^1.3.0",
-        "get-proto": "^1.0.1",
-        "get-symbol-description": "^1.1.0",
-        "globalthis": "^1.0.4",
-        "gopd": "^1.2.0",
-        "has-property-descriptors": "^1.0.2",
-        "has-proto": "^1.2.0",
-        "has-symbols": "^1.1.0",
-        "hasown": "^2.0.2",
-        "internal-slot": "^1.1.0",
-        "is-array-buffer": "^3.0.5",
-        "is-callable": "^1.2.7",
-        "is-data-view": "^1.0.2",
-        "is-negative-zero": "^2.0.3",
-        "is-regex": "^1.2.1",
-        "is-set": "^2.0.3",
-        "is-shared-array-buffer": "^1.0.4",
-        "is-string": "^1.1.1",
-        "is-typed-array": "^1.1.15",
-        "is-weakref": "^1.1.1",
-        "math-intrinsics": "^1.1.0",
-        "object-inspect": "^1.13.4",
-        "object-keys": "^1.1.1",
-        "object.assign": "^4.1.7",
-        "own-keys": "^1.0.1",
-        "regexp.prototype.flags": "^1.5.4",
-        "safe-array-concat": "^1.1.3",
-        "safe-push-apply": "^1.0.0",
-        "safe-regex-test": "^1.1.0",
-        "set-proto": "^1.0.0",
-        "stop-iteration-iterator": "^1.1.0",
-        "string.prototype.trim": "^1.2.10",
-        "string.prototype.trimend": "^1.0.9",
-        "string.prototype.trimstart": "^1.0.8",
-        "typed-array-buffer": "^1.0.3",
-        "typed-array-byte-length": "^1.0.3",
-        "typed-array-byte-offset": "^1.0.4",
-        "typed-array-length": "^1.0.7",
-        "unbox-primitive": "^1.1.0",
-        "which-typed-array": "^1.1.19"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/es-define-property": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/es-define-property/-/es-define-property-1.0.1.tgz",
-      "integrity": "sha512-e3nRfgfUZ4rNGL232gUgX06QNyyez04KdjFrF+LTRoOXmrOgFKDg4BCdsjW8EnT69eqdYGmRpJwiPVYNrCaW3g==",
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.4"
-      }
-    },
-    "node_modules/es-errors": {
-      "version": "1.3.0",
-      "resolved": "https://registry.npmjs.org/es-errors/-/es-errors-1.3.0.tgz",
-      "integrity": "sha512-Zf5H2Kxt2xjTvbJvP2ZWLEICxA6j+hAmMzIlypy4xcBg1vKVnx89Wy0GbS+kf5cwCVFFzdCFh2XSCFNULS6csw==",
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.4"
-      }
-    },
-    "node_modules/es-object-atoms": {
-      "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/es-object-atoms/-/es-object-atoms-1.1.1.tgz",
-      "integrity": "sha512-FGgH2h8zKNim9ljj7dankFPcICIK9Cp5bm+c2gQSYePhpaG5+esrLODihIorn+Pe6FGJzWhXQotPv73jTaldXA==",
-      "license": "MIT",
-      "dependencies": {
-        "es-errors": "^1.3.0"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      }
-    },
-    "node_modules/es-set-tostringtag": {
-      "version": "2.1.0",
-      "resolved": "https://registry.npmjs.org/es-set-tostringtag/-/es-set-tostringtag-2.1.0.tgz",
-      "integrity": "sha512-j6vWzfrGVfyXxge+O0x5sh6cvxAog0a/4Rdd2K36zCMV5eJ+/+tOAngRO8cODMNWbVRdVlmGZQL2YS3yR8bIUA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "es-errors": "^1.3.0",
-        "get-intrinsic": "^1.2.6",
-        "has-tostringtag": "^1.0.2",
-        "hasown": "^2.0.2"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      }
-    },
-    "node_modules/es-to-primitive": {
-      "version": "1.3.0",
-      "resolved": "https://registry.npmjs.org/es-to-primitive/-/es-to-primitive-1.3.0.tgz",
-      "integrity": "sha512-w+5mJ3GuFL+NjVtJlvydShqE1eN3h3PbI7/5LAsYJP/2qtuMXjfL2LpHSRqo4b4eSF5K/DH1JXKUAHSB2UW50g==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "is-callable": "^1.2.7",
-        "is-date-object": "^1.0.5",
-        "is-symbol": "^1.0.4"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/esbuild": {
-      "version": "0.25.6",
-      "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.25.6.tgz",
-      "integrity": "sha512-GVuzuUwtdsghE3ocJ9Bs8PNoF13HNQ5TXbEi2AhvVb8xU1Iwt9Fos9FEamfoee+u/TOsn7GUWc04lz46n2bbTg==",
-      "dev": true,
-      "hasInstallScript": true,
-      "license": "MIT",
-      "bin": {
-        "esbuild": "bin/esbuild"
-      },
-      "engines": {
-        "node": ">=18"
-      },
-      "optionalDependencies": {
-        "@esbuild/aix-ppc64": "0.25.6",
-        "@esbuild/android-arm": "0.25.6",
-        "@esbuild/android-arm64": "0.25.6",
-        "@esbuild/android-x64": "0.25.6",
-        "@esbuild/darwin-arm64": "0.25.6",
-        "@esbuild/darwin-x64": "0.25.6",
-        "@esbuild/freebsd-arm64": "0.25.6",
-        "@esbuild/freebsd-x64": "0.25.6",
-        "@esbuild/linux-arm": "0.25.6",
-        "@esbuild/linux-arm64": "0.25.6",
-        "@esbuild/linux-ia32": "0.25.6",
-        "@esbuild/linux-loong64": "0.25.6",
-        "@esbuild/linux-mips64el": "0.25.6",
-        "@esbuild/linux-ppc64": "0.25.6",
-        "@esbuild/linux-riscv64": "0.25.6",
-        "@esbuild/linux-s390x": "0.25.6",
-        "@esbuild/linux-x64": "0.25.6",
-        "@esbuild/netbsd-arm64": "0.25.6",
-        "@esbuild/netbsd-x64": "0.25.6",
-        "@esbuild/openbsd-arm64": "0.25.6",
-        "@esbuild/openbsd-x64": "0.25.6",
-        "@esbuild/openharmony-arm64": "0.25.6",
-        "@esbuild/sunos-x64": "0.25.6",
-        "@esbuild/win32-arm64": "0.25.6",
-        "@esbuild/win32-ia32": "0.25.6",
-        "@esbuild/win32-x64": "0.25.6"
-      }
-    },
-    "node_modules/escape-html": {
-      "version": "1.0.3",
-      "resolved": "https://registry.npmjs.org/escape-html/-/escape-html-1.0.3.tgz",
-      "integrity": "sha512-NiSupZ4OeuGwr68lGIeym/ksIZMJodUGOSCZ/FSnTxcrekbvqrgdUxlJOMpijaKZVjAJrWrGs/6Jy8OMuyj9ow==",
-      "license": "MIT"
-    },
-    "node_modules/escape-string-regexp": {
-      "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-4.0.0.tgz",
-      "integrity": "sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=10"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/eslint": {
-      "version": "9.30.1",
-      "resolved": "https://registry.npmjs.org/eslint/-/eslint-9.30.1.tgz",
-      "integrity": "sha512-zmxXPNMOXmwm9E0yQLi5uqXHs7uq2UIiqEKo3Gq+3fwo1XrJ+hijAZImyF7hclW3E6oHz43Yk3RP8at6OTKflQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@eslint-community/eslint-utils": "^4.2.0",
-        "@eslint-community/regexpp": "^4.12.1",
-        "@eslint/config-array": "^0.21.0",
-        "@eslint/config-helpers": "^0.3.0",
-        "@eslint/core": "^0.14.0",
-        "@eslint/eslintrc": "^3.3.1",
-        "@eslint/js": "9.30.1",
-        "@eslint/plugin-kit": "^0.3.1",
-        "@humanfs/node": "^0.16.6",
-        "@humanwhocodes/module-importer": "^1.0.1",
-        "@humanwhocodes/retry": "^0.4.2",
-        "@types/estree": "^1.0.6",
-        "@types/json-schema": "^7.0.15",
-        "ajv": "^6.12.4",
-        "chalk": "^4.0.0",
-        "cross-spawn": "^7.0.6",
-        "debug": "^4.3.2",
-        "escape-string-regexp": "^4.0.0",
-        "eslint-scope": "^8.4.0",
-        "eslint-visitor-keys": "^4.2.1",
-        "espree": "^10.4.0",
-        "esquery": "^1.5.0",
-        "esutils": "^2.0.2",
-        "fast-deep-equal": "^3.1.3",
-        "file-entry-cache": "^8.0.0",
-        "find-up": "^5.0.0",
-        "glob-parent": "^6.0.2",
-        "ignore": "^5.2.0",
-        "imurmurhash": "^0.1.4",
-        "is-glob": "^4.0.0",
-        "json-stable-stringify-without-jsonify": "^1.0.1",
-        "lodash.merge": "^4.6.2",
-        "minimatch": "^3.1.2",
-        "natural-compare": "^1.4.0",
-        "optionator": "^0.9.3"
-      },
-      "bin": {
-        "eslint": "bin/eslint.js"
-      },
-      "engines": {
-        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
-      },
-      "funding": {
-        "url": "https://eslint.org/donate"
-      },
-      "peerDependencies": {
-        "jiti": "*"
-      },
-      "peerDependenciesMeta": {
-        "jiti": {
-          "optional": true
-        }
-      }
-    },
-    "node_modules/eslint-scope": {
-      "version": "8.4.0",
-      "resolved": "https://registry.npmjs.org/eslint-scope/-/eslint-scope-8.4.0.tgz",
-      "integrity": "sha512-sNXOfKCn74rt8RICKMvJS7XKV/Xk9kA7DyJr8mJik3S7Cwgy3qlkkmyS2uQB3jiJg6VNdZd/pDBJu0nvG2NlTg==",
-      "dev": true,
-      "license": "BSD-2-Clause",
-      "dependencies": {
-        "esrecurse": "^4.3.0",
-        "estraverse": "^5.2.0"
-      },
-      "engines": {
-        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
-      },
-      "funding": {
-        "url": "https://opencollective.com/eslint"
-      }
-    },
-    "node_modules/eslint-visitor-keys": {
-      "version": "3.4.3",
-      "resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-3.4.3.tgz",
-      "integrity": "sha512-wpc+LXeiyiisxPlEkUzU6svyS1frIO3Mgxj1fdy7Pm8Ygzguax2N3Fa/D/ag1WqbOprdI+uY6wMUl8/a2G+iag==",
-      "dev": true,
-      "license": "Apache-2.0",
-      "engines": {
-        "node": "^12.22.0 || ^14.17.0 || >=16.0.0"
-      },
-      "funding": {
-        "url": "https://opencollective.com/eslint"
-      }
-    },
-    "node_modules/eslint/node_modules/brace-expansion": {
-      "version": "1.1.12",
-      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.12.tgz",
-      "integrity": "sha512-9T9UjW3r0UW5c1Q7GTwllptXwhvYmEzFhzMfZ9H7FQWt+uZePjZPjBP/W1ZEyZ1twGWom5/56TF4lPcqjnDHcg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "balanced-match": "^1.0.0",
-        "concat-map": "0.0.1"
-      }
-    },
-    "node_modules/eslint/node_modules/eslint-visitor-keys": {
-      "version": "4.2.1",
-      "resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-4.2.1.tgz",
-      "integrity": "sha512-Uhdk5sfqcee/9H/rCOJikYz67o0a2Tw2hGRPOG2Y1R2dg7brRe1uG0yaNQDHu+TO/uQPF/5eCapvYSmHUjt7JQ==",
-      "dev": true,
-      "license": "Apache-2.0",
-      "engines": {
-        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
-      },
-      "funding": {
-        "url": "https://opencollective.com/eslint"
-      }
-    },
-    "node_modules/eslint/node_modules/glob-parent": {
-      "version": "6.0.2",
-      "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-6.0.2.tgz",
-      "integrity": "sha512-XxwI8EOhVQgWp6iDL+3b0r86f4d6AX6zSU55HfB4ydCEuXLXc5FcYeOu+nnGftS4TEju/11rt4KJPTMgbfmv4A==",
-      "dev": true,
-      "license": "ISC",
-      "dependencies": {
-        "is-glob": "^4.0.3"
-      },
-      "engines": {
-        "node": ">=10.13.0"
-      }
-    },
-    "node_modules/eslint/node_modules/ignore": {
-      "version": "5.3.2",
-      "resolved": "https://registry.npmjs.org/ignore/-/ignore-5.3.2.tgz",
-      "integrity": "sha512-hsBTNUqQTDwkWtcdYI2i06Y/nUBEsNEDJKjWdigLvegy8kDuJAS8uRlpkkcQpyEXL0Z/pjDy5HBmMjRCJ2gq+g==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 4"
-      }
-    },
-    "node_modules/eslint/node_modules/minimatch": {
-      "version": "3.1.2",
-      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz",
-      "integrity": "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==",
-      "dev": true,
-      "license": "ISC",
-      "dependencies": {
-        "brace-expansion": "^1.1.7"
-      },
-      "engines": {
-        "node": "*"
-      }
-    },
-    "node_modules/espree": {
-      "version": "10.4.0",
-      "resolved": "https://registry.npmjs.org/espree/-/espree-10.4.0.tgz",
-      "integrity": "sha512-j6PAQ2uUr79PZhBjP5C5fhl8e39FmRnOjsD5lGnWrFU8i2G776tBK7+nP8KuQUTTyAZUwfQqXAgrVH5MbH9CYQ==",
-      "dev": true,
-      "license": "BSD-2-Clause",
-      "dependencies": {
-        "acorn": "^8.15.0",
-        "acorn-jsx": "^5.3.2",
-        "eslint-visitor-keys": "^4.2.1"
-      },
-      "engines": {
-        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
-      },
-      "funding": {
-        "url": "https://opencollective.com/eslint"
-      }
-    },
-    "node_modules/espree/node_modules/eslint-visitor-keys": {
-      "version": "4.2.1",
-      "resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-4.2.1.tgz",
-      "integrity": "sha512-Uhdk5sfqcee/9H/rCOJikYz67o0a2Tw2hGRPOG2Y1R2dg7brRe1uG0yaNQDHu+TO/uQPF/5eCapvYSmHUjt7JQ==",
-      "dev": true,
-      "license": "Apache-2.0",
-      "engines": {
-        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
-      },
-      "funding": {
-        "url": "https://opencollective.com/eslint"
-      }
-    },
-    "node_modules/esquery": {
-      "version": "1.6.0",
-      "resolved": "https://registry.npmjs.org/esquery/-/esquery-1.6.0.tgz",
-      "integrity": "sha512-ca9pw9fomFcKPvFLXhBKUK90ZvGibiGOvRJNbjljY7s7uq/5YO4BOzcYtJqExdx99rF6aAcnRxHmcUHcz6sQsg==",
-      "dev": true,
-      "license": "BSD-3-Clause",
-      "dependencies": {
-        "estraverse": "^5.1.0"
-      },
-      "engines": {
-        "node": ">=0.10"
-      }
-    },
-    "node_modules/esrecurse": {
-      "version": "4.3.0",
-      "resolved": "https://registry.npmjs.org/esrecurse/-/esrecurse-4.3.0.tgz",
-      "integrity": "sha512-KmfKL3b6G+RXvP8N1vr3Tq1kL/oCFgn2NYXEtqP8/L3pKapUA4G8cFVaoF3SU323CD4XypR/ffioHmkti6/Tag==",
-      "dev": true,
-      "license": "BSD-2-Clause",
-      "dependencies": {
-        "estraverse": "^5.2.0"
-      },
-      "engines": {
-        "node": ">=4.0"
-      }
-    },
-    "node_modules/estraverse": {
-      "version": "5.3.0",
-      "resolved": "https://registry.npmjs.org/estraverse/-/estraverse-5.3.0.tgz",
-      "integrity": "sha512-MMdARuVEQziNTeJD8DgMqmhwR11BRQ/cBP+pLtYdSTnf3MIO8fFeiINEbX36ZdNlfU/7A9f3gUw49B3oQsvwBA==",
-      "dev": true,
-      "license": "BSD-2-Clause",
-      "engines": {
-        "node": ">=4.0"
-      }
-    },
-    "node_modules/esutils": {
-      "version": "2.0.3",
-      "resolved": "https://registry.npmjs.org/esutils/-/esutils-2.0.3.tgz",
-      "integrity": "sha512-kVscqXk4OCp68SZ0dkgEKVi6/8ij300KBWTJq32P/dYeWTSwK41WyTxalN1eRmA5Z9UU/LX9D7FWSmV9SAYx6g==",
-      "dev": true,
-      "license": "BSD-2-Clause",
-      "engines": {
-        "node": ">=0.10.0"
-      }
-    },
-    "node_modules/etag": {
-      "version": "1.8.1",
-      "resolved": "https://registry.npmjs.org/etag/-/etag-1.8.1.tgz",
-      "integrity": "sha512-aIL5Fx7mawVa300al2BnEE4iNvo1qETxLrPI/o05L7z6go7fCw1J6EQmbK4FmJ2AS7kgVF/KEZWufBfdClMcPg==",
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.6"
-      }
-    },
-    "node_modules/eventsource": {
-      "version": "3.0.7",
-      "resolved": "https://registry.npmjs.org/eventsource/-/eventsource-3.0.7.tgz",
-      "integrity": "sha512-CRT1WTyuQoD771GW56XEZFQ/ZoSfWid1alKGDYMmkt2yl8UXrVR4pspqWNEcqKvVIzg6PAltWjxcSSPrboA4iA==",
-      "license": "MIT",
-      "dependencies": {
-        "eventsource-parser": "^3.0.1"
-      },
-      "engines": {
-        "node": ">=18.0.0"
-      }
-    },
-    "node_modules/eventsource-parser": {
-      "version": "3.0.3",
-      "resolved": "https://registry.npmjs.org/eventsource-parser/-/eventsource-parser-3.0.3.tgz",
-      "integrity": "sha512-nVpZkTMM9rF6AQ9gPJpFsNAMt48wIzB5TQgiTLdHiuO8XEDhUgZEhqKlZWXbIzo9VmJ/HvysHqEaVeD5v9TPvA==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=20.0.0"
-      }
-    },
-    "node_modules/express": {
-      "version": "5.1.0",
-      "resolved": "https://registry.npmjs.org/express/-/express-5.1.0.tgz",
-      "integrity": "sha512-DT9ck5YIRU+8GYzzU5kT3eHGA5iL+1Zd0EutOmTE9Dtk+Tvuzd23VBU+ec7HPNSTxXYO55gPV/hq4pSBJDjFpA==",
-      "license": "MIT",
-      "dependencies": {
-        "accepts": "^2.0.0",
-        "body-parser": "^2.2.0",
-        "content-disposition": "^1.0.0",
-        "content-type": "^1.0.5",
-        "cookie": "^0.7.1",
-        "cookie-signature": "^1.2.1",
-        "debug": "^4.4.0",
-        "encodeurl": "^2.0.0",
-        "escape-html": "^1.0.3",
-        "etag": "^1.8.1",
-        "finalhandler": "^2.1.0",
-        "fresh": "^2.0.0",
-        "http-errors": "^2.0.0",
-        "merge-descriptors": "^2.0.0",
-        "mime-types": "^3.0.0",
-        "on-finished": "^2.4.1",
-        "once": "^1.4.0",
-        "parseurl": "^1.3.3",
-        "proxy-addr": "^2.0.7",
-        "qs": "^6.14.0",
-        "range-parser": "^1.2.1",
-        "router": "^2.2.0",
-        "send": "^1.1.0",
-        "serve-static": "^2.2.0",
-        "statuses": "^2.0.1",
-        "type-is": "^2.0.1",
-        "vary": "^1.1.2"
-      },
-      "engines": {
-        "node": ">= 18"
-      },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/express"
-      }
-    },
-    "node_modules/express-rate-limit": {
-      "version": "7.5.1",
-      "resolved": "https://registry.npmjs.org/express-rate-limit/-/express-rate-limit-7.5.1.tgz",
-      "integrity": "sha512-7iN8iPMDzOMHPUYllBEsQdWVB6fPDMPqwjBaFrgr4Jgr/+okjvzAy+UHlYYL/Vs0OsOrMkwS6PJDkFlJwoxUnw==",
-      "license": "MIT",
-      "engines": {
-        "node": ">= 16"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/express-rate-limit"
-      },
-      "peerDependencies": {
-        "express": ">= 4.11"
-      }
-    },
-    "node_modules/fast-deep-equal": {
-      "version": "3.1.3",
-      "resolved": "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz",
-      "integrity": "sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==",
-      "license": "MIT"
-    },
-    "node_modules/fast-glob": {
-      "version": "3.3.3",
-      "resolved": "https://registry.npmjs.org/fast-glob/-/fast-glob-3.3.3.tgz",
-      "integrity": "sha512-7MptL8U0cqcFdzIzwOTHoilX9x5BrNqye7Z/LuC7kCMRio1EMSyqRK3BEAUD7sXRq4iT4AzTVuZdhgQ2TCvYLg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@nodelib/fs.stat": "^2.0.2",
-        "@nodelib/fs.walk": "^1.2.3",
-        "glob-parent": "^5.1.2",
-        "merge2": "^1.3.0",
-        "micromatch": "^4.0.8"
-      },
-      "engines": {
-        "node": ">=8.6.0"
-      }
-    },
-    "node_modules/fast-json-stable-stringify": {
-      "version": "2.1.0",
-      "resolved": "https://registry.npmjs.org/fast-json-stable-stringify/-/fast-json-stable-stringify-2.1.0.tgz",
-      "integrity": "sha512-lhd/wF+Lk98HZoTCtlVraHtfh5XYijIjalXck7saUtuanSDyLMxnHhSXEDJqHxD7msR8D0uCmqlkwjCV8xvwHw==",
-      "license": "MIT"
-    },
-    "node_modules/fast-levenshtein": {
-      "version": "2.0.6",
-      "resolved": "https://registry.npmjs.org/fast-levenshtein/-/fast-levenshtein-2.0.6.tgz",
-      "integrity": "sha512-DCXu6Ifhqcks7TZKY3Hxp3y6qphY5SJZmrWMDrKcERSOXWQdMhU9Ig/PYrzyw/ul9jOIyh0N4M0tbC5hodg8dw==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/fastq": {
-      "version": "1.19.1",
-      "resolved": "https://registry.npmjs.org/fastq/-/fastq-1.19.1.tgz",
-      "integrity": "sha512-GwLTyxkCXjXbxqIhTsMI2Nui8huMPtnxg7krajPJAjnEG/iiOS7i+zCtWGZR9G0NBKbXKh6X9m9UIsYX/N6vvQ==",
-      "dev": true,
-      "license": "ISC",
-      "dependencies": {
-        "reusify": "^1.0.4"
-      }
-    },
-    "node_modules/file-entry-cache": {
-      "version": "8.0.0",
-      "resolved": "https://registry.npmjs.org/file-entry-cache/-/file-entry-cache-8.0.0.tgz",
-      "integrity": "sha512-XXTUwCvisa5oacNGRP9SfNtYBNAMi+RPwBFmblZEF7N7swHYQS6/Zfk7SRwx4D5j3CH211YNRco1DEMNVfZCnQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "flat-cache": "^4.0.0"
-      },
-      "engines": {
-        "node": ">=16.0.0"
-      }
-    },
-    "node_modules/fill-range": {
-      "version": "7.1.1",
-      "resolved": "https://registry.npmjs.org/fill-range/-/fill-range-7.1.1.tgz",
-      "integrity": "sha512-YsGpe3WHLK8ZYi4tWDg2Jy3ebRz2rXowDxnld4bkQB00cc/1Zw9AWnC0i9ztDJitivtQvaI9KaLyKrc+hBW0yg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "to-regex-range": "^5.0.1"
-      },
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/finalhandler": {
-      "version": "2.1.0",
-      "resolved": "https://registry.npmjs.org/finalhandler/-/finalhandler-2.1.0.tgz",
-      "integrity": "sha512-/t88Ty3d5JWQbWYgaOGCCYfXRwV1+be02WqYYlL6h0lEiUAMPM8o8qKGO01YIkOHzka2up08wvgYD0mDiI+q3Q==",
-      "license": "MIT",
-      "dependencies": {
-        "debug": "^4.4.0",
-        "encodeurl": "^2.0.0",
-        "escape-html": "^1.0.3",
-        "on-finished": "^2.4.1",
-        "parseurl": "^1.3.3",
-        "statuses": "^2.0.1"
-      },
-      "engines": {
-        "node": ">= 0.8"
-      }
-    },
-    "node_modules/find-up": {
-      "version": "5.0.0",
-      "resolved": "https://registry.npmjs.org/find-up/-/find-up-5.0.0.tgz",
-      "integrity": "sha512-78/PXT1wlLLDgTzDs7sjq9hzz0vXD+zn+7wypEe4fXQxCmdmqfGsEPQxmiCSQI3ajFV91bVSsvNtrJRiW6nGng==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "locate-path": "^6.0.0",
-        "path-exists": "^4.0.0"
-      },
-      "engines": {
-        "node": ">=10"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/flat-cache": {
-      "version": "4.0.1",
-      "resolved": "https://registry.npmjs.org/flat-cache/-/flat-cache-4.0.1.tgz",
-      "integrity": "sha512-f7ccFPK3SXFHpx15UIGyRJ/FJQctuKZ0zVuN3frBo4HnK3cay9VEW0R6yPYFHC0AgqhukPzKjq22t5DmAyqGyw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "flatted": "^3.2.9",
-        "keyv": "^4.5.4"
-      },
-      "engines": {
-        "node": ">=16"
-      }
-    },
-    "node_modules/flatted": {
-      "version": "3.3.3",
-      "resolved": "https://registry.npmjs.org/flatted/-/flatted-3.3.3.tgz",
-      "integrity": "sha512-GX+ysw4PBCz0PzosHDepZGANEuFCMLrnRTiEy9McGjmkCQYwRq4A/X786G/fjM/+OjsWSU1ZrY5qyARZmO/uwg==",
-      "dev": true,
-      "license": "ISC"
-    },
-    "node_modules/for-each": {
-      "version": "0.3.5",
-      "resolved": "https://registry.npmjs.org/for-each/-/for-each-0.3.5.tgz",
-      "integrity": "sha512-dKx12eRCVIzqCxFGplyFKJMPvLEWgmNtUrpTiJIR5u97zEhRG8ySrtboPHZXx7daLxQVrl643cTzbab2tkQjxg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "is-callable": "^1.2.7"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/forwarded": {
-      "version": "0.2.0",
-      "resolved": "https://registry.npmjs.org/forwarded/-/forwarded-0.2.0.tgz",
-      "integrity": "sha512-buRG0fpBtRHSTCOASe6hD258tEubFoRLb4ZNA6NxMVHNw2gOcwHo9wyablzMzOA5z9xA9L1KNjk/Nt6MT9aYow==",
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.6"
-      }
-    },
-    "node_modules/fresh": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/fresh/-/fresh-2.0.0.tgz",
-      "integrity": "sha512-Rx/WycZ60HOaqLKAi6cHRKKI7zxWbJ31MhntmtwMoaTeF7XFH9hhBp8vITaMidfljRQ6eYWCKkaTK+ykVJHP2A==",
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.8"
-      }
-    },
-    "node_modules/function-bind": {
-      "version": "1.1.2",
-      "resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.2.tgz",
-      "integrity": "sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA==",
-      "license": "MIT",
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/function.prototype.name": {
-      "version": "1.1.8",
-      "resolved": "https://registry.npmjs.org/function.prototype.name/-/function.prototype.name-1.1.8.tgz",
-      "integrity": "sha512-e5iwyodOHhbMr/yNrc7fDYG4qlbIvI5gajyzPnb5TCwyhjApznQh1BMFou9b30SevY43gCJKXycoCBjMbsuW0Q==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "call-bind": "^1.0.8",
-        "call-bound": "^1.0.3",
-        "define-properties": "^1.2.1",
-        "functions-have-names": "^1.2.3",
-        "hasown": "^2.0.2",
-        "is-callable": "^1.2.7"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/functions-have-names": {
-      "version": "1.2.3",
-      "resolved": "https://registry.npmjs.org/functions-have-names/-/functions-have-names-1.2.3.tgz",
-      "integrity": "sha512-xckBUXyTIqT97tq2x2AMb+g163b5JFysYk0x4qxNFwbfQkmNZoiRHb6sPzI9/QV33WeuvVYBUIiD4NzNIyqaRQ==",
-      "dev": true,
-      "license": "MIT",
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/get-intrinsic": {
-      "version": "1.3.0",
-      "resolved": "https://registry.npmjs.org/get-intrinsic/-/get-intrinsic-1.3.0.tgz",
-      "integrity": "sha512-9fSjSaos/fRIVIp+xSJlE6lfwhES7LNtKaCBIamHsjr2na1BiABJPo0mOjjz8GJDURarmCPGqaiVg5mfjb98CQ==",
-      "license": "MIT",
-      "dependencies": {
-        "call-bind-apply-helpers": "^1.0.2",
-        "es-define-property": "^1.0.1",
-        "es-errors": "^1.3.0",
-        "es-object-atoms": "^1.1.1",
-        "function-bind": "^1.1.2",
-        "get-proto": "^1.0.1",
-        "gopd": "^1.2.0",
-        "has-symbols": "^1.1.0",
-        "hasown": "^2.0.2",
-        "math-intrinsics": "^1.1.0"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/get-proto": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/get-proto/-/get-proto-1.0.1.tgz",
-      "integrity": "sha512-sTSfBjoXBp89JvIKIefqw7U2CCebsc74kiY6awiGogKtoSGbgjYE/G/+l9sF3MWFPNc9IcoOC4ODfKHfxFmp0g==",
-      "license": "MIT",
-      "dependencies": {
-        "dunder-proto": "^1.0.1",
-        "es-object-atoms": "^1.0.0"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      }
-    },
-    "node_modules/get-symbol-description": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/get-symbol-description/-/get-symbol-description-1.1.0.tgz",
-      "integrity": "sha512-w9UMqWwJxHNOvoNzSJ2oPF5wvYcvP7jUvYzhp67yEhTi17ZDBBC1z9pTdGuzjD+EFIqLSYRweZjqfiPzQ06Ebg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "call-bound": "^1.0.3",
-        "es-errors": "^1.3.0",
-        "get-intrinsic": "^1.2.6"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/glob-parent": {
-      "version": "5.1.2",
-      "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-5.1.2.tgz",
-      "integrity": "sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==",
-      "dev": true,
-      "license": "ISC",
-      "dependencies": {
-        "is-glob": "^4.0.1"
-      },
-      "engines": {
-        "node": ">= 6"
-      }
-    },
-    "node_modules/globals": {
-      "version": "14.0.0",
-      "resolved": "https://registry.npmjs.org/globals/-/globals-14.0.0.tgz",
-      "integrity": "sha512-oahGvuMGQlPw/ivIYBjVSrWAfWLBeku5tpPE2fOPLi+WHffIWbuh2tCjhyQhTBPMf5E9jDEH4FOmTYgYwbKwtQ==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=18"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/globalthis": {
-      "version": "1.0.4",
-      "resolved": "https://registry.npmjs.org/globalthis/-/globalthis-1.0.4.tgz",
-      "integrity": "sha512-DpLKbNU4WylpxJykQujfCcwYWiV/Jhm50Goo0wrVILAv5jOr9d+H+UR3PhSCD2rCCEIg0uc+G+muBTwD54JhDQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "define-properties": "^1.2.1",
-        "gopd": "^1.0.1"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/gopd": {
-      "version": "1.2.0",
-      "resolved": "https://registry.npmjs.org/gopd/-/gopd-1.2.0.tgz",
-      "integrity": "sha512-ZUKRh6/kUFoAiTAtTYPZJ3hw9wNxx+BIBOijnlG9PnrJsCcSjs1wyyD6vJpaYtgnzDrKYRSqf3OO6Rfa93xsRg==",
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/graceful-fs": {
-      "version": "4.2.11",
-      "resolved": "https://registry.npmjs.org/graceful-fs/-/graceful-fs-4.2.11.tgz",
-      "integrity": "sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ==",
-      "dev": true,
-      "license": "ISC"
-    },
-    "node_modules/graphemer": {
-      "version": "1.4.0",
-      "resolved": "https://registry.npmjs.org/graphemer/-/graphemer-1.4.0.tgz",
-      "integrity": "sha512-EtKwoO6kxCL9WO5xipiHTZlSzBm7WLT627TqC/uVRd0HKmq8NXyebnNYxDoBi7wt8eTWrUrKXCOVaFq9x1kgag==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/has-bigints": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/has-bigints/-/has-bigints-1.1.0.tgz",
-      "integrity": "sha512-R3pbpkcIqv2Pm3dUwgjclDRVmWpTJW2DcMzcIhEXEx1oh/CEMObMm3KLmRJOdvhM7o4uQBnwr8pzRK2sJWIqfg==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/has-flag": {
-      "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz",
-      "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/has-property-descriptors": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/has-property-descriptors/-/has-property-descriptors-1.0.2.tgz",
-      "integrity": "sha512-55JNKuIW+vq4Ke1BjOTjM2YctQIvCT7GFzHwmfZPGo5wnrgkid0YQtnAleFSqumZm4az3n2BS+erby5ipJdgrg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "es-define-property": "^1.0.0"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/has-proto": {
-      "version": "1.2.0",
-      "resolved": "https://registry.npmjs.org/has-proto/-/has-proto-1.2.0.tgz",
-      "integrity": "sha512-KIL7eQPfHQRC8+XluaIw7BHUwwqL19bQn4hzNgdr+1wXoU0KKj6rufu47lhY7KbJR2C6T6+PfyN0Ea7wkSS+qQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "dunder-proto": "^1.0.0"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/has-symbols": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/has-symbols/-/has-symbols-1.1.0.tgz",
-      "integrity": "sha512-1cDNdwJ2Jaohmb3sg4OmKaMBwuC48sYni5HUw2DvsC8LjGTLK9h+eb1X6RyuOHe4hT0ULCW68iomhjUoKUqlPQ==",
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/has-tostringtag": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/has-tostringtag/-/has-tostringtag-1.0.2.tgz",
-      "integrity": "sha512-NqADB8VjPFLM2V0VvHUewwwsw0ZWBaIdgo+ieHtK3hasLz4qeCRjYcqfB6AQrBggRKppKF8L52/VqdVsO47Dlw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "has-symbols": "^1.0.3"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/hasown": {
-      "version": "2.0.2",
-      "resolved": "https://registry.npmjs.org/hasown/-/hasown-2.0.2.tgz",
-      "integrity": "sha512-0hJU9SCPvmMzIBdZFqNPXWa6dqh7WdH0cII9y+CyS8rG3nL48Bclra9HmKhVVUHyPWNH5Y7xDwAB7bfgSjkUMQ==",
-      "license": "MIT",
-      "dependencies": {
-        "function-bind": "^1.1.2"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      }
-    },
-    "node_modules/hosted-git-info": {
-      "version": "2.8.9",
-      "resolved": "https://registry.npmjs.org/hosted-git-info/-/hosted-git-info-2.8.9.tgz",
-      "integrity": "sha512-mxIDAb9Lsm6DoOJ7xH+5+X4y1LU/4Hi50L9C5sIswK3JzULS4bwk1FvjdBgvYR4bzT4tuUQiC15FE2f5HbLvYw==",
-      "dev": true,
-      "license": "ISC"
-    },
-    "node_modules/http-errors": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/http-errors/-/http-errors-2.0.0.tgz",
-      "integrity": "sha512-FtwrG/euBzaEjYeRqOgly7G0qviiXoJWnvEH2Z1plBdXgbyjv34pHTSb9zoeHMyDy33+DWy5Wt9Wo+TURtOYSQ==",
-      "license": "MIT",
-      "dependencies": {
-        "depd": "2.0.0",
-        "inherits": "2.0.4",
-        "setprototypeof": "1.2.0",
-        "statuses": "2.0.1",
-        "toidentifier": "1.0.1"
-      },
-      "engines": {
-        "node": ">= 0.8"
-      }
-    },
-    "node_modules/http-errors/node_modules/statuses": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/statuses/-/statuses-2.0.1.tgz",
-      "integrity": "sha512-RwNA9Z/7PrK06rYLIzFMlaF+l73iwpzsqRIFgbMLbTcLD6cOao82TaWefPXQvB2fOC4AjuYSEndS7N/mTCbkdQ==",
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.8"
-      }
-    },
-    "node_modules/iconv-lite": {
-      "version": "0.6.3",
-      "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.6.3.tgz",
-      "integrity": "sha512-4fCk79wshMdzMp2rH06qWrJE4iolqLhCUH+OiuIgU++RB0+94NlDL81atO7GX55uUKueo0txHNtvEyI6D7WdMw==",
-      "license": "MIT",
-      "dependencies": {
-        "safer-buffer": ">= 2.1.2 < 3.0.0"
-      },
-      "engines": {
-        "node": ">=0.10.0"
-      }
-    },
-    "node_modules/ignore": {
-      "version": "7.0.5",
-      "resolved": "https://registry.npmjs.org/ignore/-/ignore-7.0.5.tgz",
-      "integrity": "sha512-Hs59xBNfUIunMFgWAbGX5cq6893IbWg4KnrjbYwX3tx0ztorVgTDA6B2sxf8ejHJ4wz8BqGUMYlnzNBer5NvGg==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 4"
-      }
-    },
-    "node_modules/import-fresh": {
-      "version": "3.3.1",
-      "resolved": "https://registry.npmjs.org/import-fresh/-/import-fresh-3.3.1.tgz",
-      "integrity": "sha512-TR3KfrTZTYLPB6jUjfx6MF9WcWrHL9su5TObK4ZkYgBdWKPOFoSoQIdEuTuR82pmtxH2spWG9h6etwfr1pLBqQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "parent-module": "^1.0.0",
-        "resolve-from": "^4.0.0"
-      },
-      "engines": {
-        "node": ">=6"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/imurmurhash": {
-      "version": "0.1.4",
-      "resolved": "https://registry.npmjs.org/imurmurhash/-/imurmurhash-0.1.4.tgz",
-      "integrity": "sha512-JmXMZ6wuvDmLiHEml9ykzqO6lwFbof0GG4IkcGaENdCRDDmMVnny7s5HsIgHCbaq0w2MyPhDqkhTUgS2LU2PHA==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=0.8.19"
-      }
-    },
-    "node_modules/inherits": {
-      "version": "2.0.4",
-      "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz",
-      "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==",
-      "license": "ISC"
-    },
-    "node_modules/internal-slot": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/internal-slot/-/internal-slot-1.1.0.tgz",
-      "integrity": "sha512-4gd7VpWNQNB4UKKCFFVcp1AVv+FMOgs9NKzjHKusc8jTMhd5eL1NqQqOpE0KzMds804/yHlglp3uxgluOqAPLw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "es-errors": "^1.3.0",
-        "hasown": "^2.0.2",
-        "side-channel": "^1.1.0"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      }
-    },
-    "node_modules/ipaddr.js": {
-      "version": "1.9.1",
-      "resolved": "https://registry.npmjs.org/ipaddr.js/-/ipaddr.js-1.9.1.tgz",
-      "integrity": "sha512-0KI/607xoxSToH7GjN1FfSbLoU0+btTicjsQSWQlh/hZykN8KpmMf7uYwPW3R+akZ6R/w18ZlXSHBYXiYUPO3g==",
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.10"
-      }
-    },
-    "node_modules/is-array-buffer": {
-      "version": "3.0.5",
-      "resolved": "https://registry.npmjs.org/is-array-buffer/-/is-array-buffer-3.0.5.tgz",
-      "integrity": "sha512-DDfANUiiG2wC1qawP66qlTugJeL5HyzMpfr8lLK+jMQirGzNod0B12cFB/9q838Ru27sBwfw78/rdoU7RERz6A==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "call-bind": "^1.0.8",
-        "call-bound": "^1.0.3",
-        "get-intrinsic": "^1.2.6"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/is-arrayish": {
-      "version": "0.2.1",
-      "resolved": "https://registry.npmjs.org/is-arrayish/-/is-arrayish-0.2.1.tgz",
-      "integrity": "sha512-zz06S8t0ozoDXMG+ube26zeCTNXcKIPJZJi8hBrF4idCLms4CG9QtK7qBl1boi5ODzFpjswb5JPmHCbMpjaYzg==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/is-async-function": {
-      "version": "2.1.1",
-      "resolved": "https://registry.npmjs.org/is-async-function/-/is-async-function-2.1.1.tgz",
-      "integrity": "sha512-9dgM/cZBnNvjzaMYHVoxxfPj2QXt22Ev7SuuPrs+xav0ukGB0S6d4ydZdEiM48kLx5kDV+QBPrpVnFyefL8kkQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "async-function": "^1.0.0",
-        "call-bound": "^1.0.3",
-        "get-proto": "^1.0.1",
-        "has-tostringtag": "^1.0.2",
-        "safe-regex-test": "^1.1.0"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/is-bigint": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/is-bigint/-/is-bigint-1.1.0.tgz",
-      "integrity": "sha512-n4ZT37wG78iz03xPRKJrHTdZbe3IicyucEtdRsV5yglwc3GyUfbAfpSeD0FJ41NbUNSt5wbhqfp1fS+BgnvDFQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "has-bigints": "^1.0.2"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/is-boolean-object": {
-      "version": "1.2.2",
-      "resolved": "https://registry.npmjs.org/is-boolean-object/-/is-boolean-object-1.2.2.tgz",
-      "integrity": "sha512-wa56o2/ElJMYqjCjGkXri7it5FbebW5usLw/nPmCMs5DeZ7eziSYZhSmPRn0txqeW4LnAmQQU7FgqLpsEFKM4A==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "call-bound": "^1.0.3",
-        "has-tostringtag": "^1.0.2"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/is-callable": {
-      "version": "1.2.7",
-      "resolved": "https://registry.npmjs.org/is-callable/-/is-callable-1.2.7.tgz",
-      "integrity": "sha512-1BC0BVFhS/p0qtw6enp8e+8OD0UrK0oFLztSjNzhcKA3WDuJxxAPXzPuPtKkjEY9UUoEWlX/8fgKeu2S8i9JTA==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/is-core-module": {
-      "version": "2.16.1",
-      "resolved": "https://registry.npmjs.org/is-core-module/-/is-core-module-2.16.1.tgz",
-      "integrity": "sha512-UfoeMA6fIJ8wTYFEUjelnaGI67v6+N7qXJEvQuIGa99l4xsCruSYOVSQ0uPANn4dAzm8lkYPaKLrrijLq7x23w==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "hasown": "^2.0.2"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/is-data-view": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/is-data-view/-/is-data-view-1.0.2.tgz",
-      "integrity": "sha512-RKtWF8pGmS87i2D6gqQu/l7EYRlVdfzemCJN/P3UOs//x1QE7mfhvzHIApBTRf7axvT6DMGwSwBXYCT0nfB9xw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "call-bound": "^1.0.2",
-        "get-intrinsic": "^1.2.6",
-        "is-typed-array": "^1.1.13"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/is-date-object": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/is-date-object/-/is-date-object-1.1.0.tgz",
-      "integrity": "sha512-PwwhEakHVKTdRNVOw+/Gyh0+MzlCl4R6qKvkhuvLtPMggI1WAHt9sOwZxQLSGpUaDnrdyDsomoRgNnCfKNSXXg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "call-bound": "^1.0.2",
-        "has-tostringtag": "^1.0.2"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/is-extglob": {
-      "version": "2.1.1",
-      "resolved": "https://registry.npmjs.org/is-extglob/-/is-extglob-2.1.1.tgz",
-      "integrity": "sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=0.10.0"
-      }
-    },
-    "node_modules/is-finalizationregistry": {
-      "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/is-finalizationregistry/-/is-finalizationregistry-1.1.1.tgz",
-      "integrity": "sha512-1pC6N8qWJbWoPtEjgcL2xyhQOP491EQjeUo3qTKcmV8YSDDJrOepfG8pcC7h/QgnQHYSv0mJ3Z/ZWxmatVrysg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "call-bound": "^1.0.3"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/is-generator-function": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/is-generator-function/-/is-generator-function-1.1.0.tgz",
-      "integrity": "sha512-nPUB5km40q9e8UfN/Zc24eLlzdSf9OfKByBw9CIdw4H1giPMeA0OIJvbchsCu4npfI2QcMVBsGEBHKZ7wLTWmQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "call-bound": "^1.0.3",
-        "get-proto": "^1.0.0",
-        "has-tostringtag": "^1.0.2",
-        "safe-regex-test": "^1.1.0"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/is-glob": {
-      "version": "4.0.3",
-      "resolved": "https://registry.npmjs.org/is-glob/-/is-glob-4.0.3.tgz",
-      "integrity": "sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "is-extglob": "^2.1.1"
-      },
-      "engines": {
-        "node": ">=0.10.0"
-      }
-    },
-    "node_modules/is-map": {
-      "version": "2.0.3",
-      "resolved": "https://registry.npmjs.org/is-map/-/is-map-2.0.3.tgz",
-      "integrity": "sha512-1Qed0/Hr2m+YqxnM09CjA2d/i6YZNfF6R2oRAOj36eUdS6qIV/huPJNSEpKbupewFs+ZsJlxsjjPbc0/afW6Lw==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/is-negative-zero": {
-      "version": "2.0.3",
-      "resolved": "https://registry.npmjs.org/is-negative-zero/-/is-negative-zero-2.0.3.tgz",
-      "integrity": "sha512-5KoIu2Ngpyek75jXodFvnafB6DJgr3u8uuK0LEZJjrU19DrMD3EVERaR8sjz8CCGgpZvxPl9SuE1GMVPFHx1mw==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/is-number": {
-      "version": "7.0.0",
-      "resolved": "https://registry.npmjs.org/is-number/-/is-number-7.0.0.tgz",
-      "integrity": "sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=0.12.0"
-      }
-    },
-    "node_modules/is-number-object": {
-      "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/is-number-object/-/is-number-object-1.1.1.tgz",
-      "integrity": "sha512-lZhclumE1G6VYD8VHe35wFaIif+CTy5SJIi5+3y4psDgWu4wPDoBhF8NxUOinEc7pHgiTsT6MaBb92rKhhD+Xw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "call-bound": "^1.0.3",
-        "has-tostringtag": "^1.0.2"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/is-promise": {
-      "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/is-promise/-/is-promise-4.0.0.tgz",
-      "integrity": "sha512-hvpoI6korhJMnej285dSg6nu1+e6uxs7zG3BYAm5byqDsgJNWwxzM6z6iZiAgQR4TJ30JmBTOwqZUw3WlyH3AQ==",
-      "license": "MIT"
-    },
-    "node_modules/is-regex": {
-      "version": "1.2.1",
-      "resolved": "https://registry.npmjs.org/is-regex/-/is-regex-1.2.1.tgz",
-      "integrity": "sha512-MjYsKHO5O7mCsmRGxWcLWheFqN9DJ/2TmngvjKXihe6efViPqc274+Fx/4fYj/r03+ESvBdTXK0V6tA3rgez1g==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "call-bound": "^1.0.2",
-        "gopd": "^1.2.0",
-        "has-tostringtag": "^1.0.2",
-        "hasown": "^2.0.2"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/is-set": {
-      "version": "2.0.3",
-      "resolved": "https://registry.npmjs.org/is-set/-/is-set-2.0.3.tgz",
-      "integrity": "sha512-iPAjerrse27/ygGLxw+EBR9agv9Y6uLeYVJMu+QNCoouJ1/1ri0mGrcWpfCqFZuzzx3WjtwxG098X+n4OuRkPg==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/is-shared-array-buffer": {
-      "version": "1.0.4",
-      "resolved": "https://registry.npmjs.org/is-shared-array-buffer/-/is-shared-array-buffer-1.0.4.tgz",
-      "integrity": "sha512-ISWac8drv4ZGfwKl5slpHG9OwPNty4jOWPRIhBpxOoD+hqITiwuipOQ2bNthAzwA3B4fIjO4Nln74N0S9byq8A==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "call-bound": "^1.0.3"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/is-string": {
-      "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/is-string/-/is-string-1.1.1.tgz",
-      "integrity": "sha512-BtEeSsoaQjlSPBemMQIrY1MY0uM6vnS1g5fmufYOtnxLGUZM2178PKbhsk7Ffv58IX+ZtcvoGwccYsh0PglkAA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "call-bound": "^1.0.3",
-        "has-tostringtag": "^1.0.2"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/is-symbol": {
-      "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/is-symbol/-/is-symbol-1.1.1.tgz",
-      "integrity": "sha512-9gGx6GTtCQM73BgmHQXfDmLtfjjTUDSyoxTCbp5WtoixAhfgsDirWIcVQ/IHpvI5Vgd5i/J5F7B9cN/WlVbC/w==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "call-bound": "^1.0.2",
-        "has-symbols": "^1.1.0",
-        "safe-regex-test": "^1.1.0"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/is-typed-array": {
-      "version": "1.1.15",
-      "resolved": "https://registry.npmjs.org/is-typed-array/-/is-typed-array-1.1.15.tgz",
-      "integrity": "sha512-p3EcsicXjit7SaskXHs1hA91QxgTw46Fv6EFKKGS5DRFLD8yKnohjF3hxoju94b/OcMZoQukzpPpBE9uLVKzgQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "which-typed-array": "^1.1.16"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/is-weakmap": {
-      "version": "2.0.2",
-      "resolved": "https://registry.npmjs.org/is-weakmap/-/is-weakmap-2.0.2.tgz",
-      "integrity": "sha512-K5pXYOm9wqY1RgjpL3YTkF39tni1XajUIkawTLUo9EZEVUFga5gSQJF8nNS7ZwJQ02y+1YCNYcMh+HIf1ZqE+w==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/is-weakref": {
-      "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/is-weakref/-/is-weakref-1.1.1.tgz",
-      "integrity": "sha512-6i9mGWSlqzNMEqpCp93KwRS1uUOodk2OJ6b+sq7ZPDSy2WuI5NFIxp/254TytR8ftefexkWn5xNiHUNpPOfSew==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "call-bound": "^1.0.3"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/is-weakset": {
-      "version": "2.0.4",
-      "resolved": "https://registry.npmjs.org/is-weakset/-/is-weakset-2.0.4.tgz",
-      "integrity": "sha512-mfcwb6IzQyOKTs84CQMrOwW4gQcaTOAWJ0zzJCl2WSPDrWk/OzDaImWFH3djXhb24g4eudZfLRozAvPGw4d9hQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "call-bound": "^1.0.3",
-        "get-intrinsic": "^1.2.6"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/isexe": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz",
-      "integrity": "sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==",
-      "license": "ISC"
-    },
-    "node_modules/js-yaml": {
-      "version": "4.1.0",
-      "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-4.1.0.tgz",
-      "integrity": "sha512-wpxZs9NoxZaJESJGIZTyDEaYpl0FKSA+FB9aJiyemKhMwkxQg63h4T1KJgUGHpTqPDNRcmmYLugrRjJlBtWvRA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "argparse": "^2.0.1"
-      },
-      "bin": {
-        "js-yaml": "bin/js-yaml.js"
-      }
-    },
-    "node_modules/json-buffer": {
-      "version": "3.0.1",
-      "resolved": "https://registry.npmjs.org/json-buffer/-/json-buffer-3.0.1.tgz",
-      "integrity": "sha512-4bV5BfR2mqfQTJm+V5tPPdf+ZpuhiIvTuAB5g8kcrXOZpTT/QwwVRWBywX1ozr6lEuPdbHxwaJlm9G6mI2sfSQ==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/json-parse-better-errors": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/json-parse-better-errors/-/json-parse-better-errors-1.0.2.tgz",
-      "integrity": "sha512-mrqyZKfX5EhL7hvqcV6WG1yYjnjeuYDzDhhcAAUrq8Po85NBQBJP+ZDUT75qZQ98IkUoBqdkExkukOU7Ts2wrw==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/json-schema-traverse": {
-      "version": "0.4.1",
-      "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-0.4.1.tgz",
-      "integrity": "sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg==",
-      "license": "MIT"
-    },
-    "node_modules/json-stable-stringify-without-jsonify": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/json-stable-stringify-without-jsonify/-/json-stable-stringify-without-jsonify-1.0.1.tgz",
-      "integrity": "sha512-Bdboy+l7tA3OGW6FjyFHWkP5LuByj1Tk33Ljyq0axyzdk9//JSi2u3fP1QSmd1KNwq6VOKYGlAu87CisVir6Pw==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/keyv": {
-      "version": "4.5.4",
-      "resolved": "https://registry.npmjs.org/keyv/-/keyv-4.5.4.tgz",
-      "integrity": "sha512-oxVHkHR/EJf2CNXnWxRLW6mg7JyCCUcG0DtEGmL2ctUo1PNTin1PUil+r/+4r5MpVgC/fn1kjsx7mjSujKqIpw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "json-buffer": "3.0.1"
-      }
-    },
-    "node_modules/levn": {
-      "version": "0.4.1",
-      "resolved": "https://registry.npmjs.org/levn/-/levn-0.4.1.tgz",
-      "integrity": "sha512-+bT2uH4E5LGE7h/n3evcS/sQlJXCpIp6ym8OWJ5eV6+67Dsql/LaaT7qJBAt2rzfoa/5QBGBhxDix1dMt2kQKQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "prelude-ls": "^1.2.1",
-        "type-check": "~0.4.0"
-      },
-      "engines": {
-        "node": ">= 0.8.0"
-      }
-    },
-    "node_modules/load-json-file": {
-      "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/load-json-file/-/load-json-file-4.0.0.tgz",
-      "integrity": "sha512-Kx8hMakjX03tiGTLAIdJ+lL0htKnXjEZN6hk/tozf/WOuYGdZBJrZ+rCJRbVCugsjB3jMLn9746NsQIf5VjBMw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "graceful-fs": "^4.1.2",
-        "parse-json": "^4.0.0",
-        "pify": "^3.0.0",
-        "strip-bom": "^3.0.0"
-      },
-      "engines": {
-        "node": ">=4"
-      }
-    },
-    "node_modules/locate-path": {
-      "version": "6.0.0",
-      "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-6.0.0.tgz",
-      "integrity": "sha512-iPZK6eYjbxRu3uB4/WZ3EsEIMJFMqAoopl3R+zuq0UjcAm/MO6KCweDgPfP3elTztoKP3KtnVHxTn2NHBSDVUw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "p-locate": "^5.0.0"
-      },
-      "engines": {
-        "node": ">=10"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/lodash.merge": {
-      "version": "4.6.2",
-      "resolved": "https://registry.npmjs.org/lodash.merge/-/lodash.merge-4.6.2.tgz",
-      "integrity": "sha512-0KpjqXRVvrYyCsX1swR/XTK0va6VQkQM6MNo7PqW77ByjAhoARA8EfrP1N4+KlKj8YS0ZUCtRT/YUuhyYDujIQ==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/math-intrinsics": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/math-intrinsics/-/math-intrinsics-1.1.0.tgz",
-      "integrity": "sha512-/IXtbwEk5HTPyEwyKX6hGkYXxM9nbj64B+ilVJnC/R6B0pH5G4V3b0pVbL7DBj4tkhBAppbQUlf6F6Xl9LHu1g==",
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.4"
-      }
-    },
-    "node_modules/media-typer": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/media-typer/-/media-typer-1.1.0.tgz",
-      "integrity": "sha512-aisnrDP4GNe06UcKFnV5bfMNPBUw4jsLGaWwWfnH3v02GnBuXX2MCVn5RbrWo0j3pczUilYblq7fQ7Nw2t5XKw==",
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.8"
-      }
-    },
-    "node_modules/memorystream": {
-      "version": "0.3.1",
-      "resolved": "https://registry.npmjs.org/memorystream/-/memorystream-0.3.1.tgz",
-      "integrity": "sha512-S3UwM3yj5mtUSEfP41UZmt/0SCoVYUcU1rkXv+BQ5Ig8ndL4sPoJNBUJERafdPb5jjHJGuMgytgKvKIf58XNBw==",
-      "dev": true,
-      "engines": {
-        "node": ">= 0.10.0"
-      }
-    },
-    "node_modules/merge-descriptors": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/merge-descriptors/-/merge-descriptors-2.0.0.tgz",
-      "integrity": "sha512-Snk314V5ayFLhp3fkUREub6WtjBfPdCPY1Ln8/8munuLuiYhsABgBVWsozAG+MWMbVEvcdcpbi9R7ww22l9Q3g==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=18"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/merge2": {
-      "version": "1.4.1",
-      "resolved": "https://registry.npmjs.org/merge2/-/merge2-1.4.1.tgz",
-      "integrity": "sha512-8q7VEgMJW4J8tcfVPy8g09NcQwZdbwFEqhe/WZkoIzjn/3TGDwtOCYtXGxA3O8tPzpczCCDgv+P2P5y00ZJOOg==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 8"
-      }
-    },
-    "node_modules/micromatch": {
-      "version": "4.0.8",
-      "resolved": "https://registry.npmjs.org/micromatch/-/micromatch-4.0.8.tgz",
-      "integrity": "sha512-PXwfBhYu0hBCPw8Dn0E+WDYb7af3dSLVWKi3HGv84IdF4TyFoC0ysxFd0Goxw7nSv4T/PzEJQxsYsEiFCKo2BA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "braces": "^3.0.3",
-        "picomatch": "^2.3.1"
-      },
-      "engines": {
-        "node": ">=8.6"
-      }
-    },
-    "node_modules/mime-db": {
-      "version": "1.54.0",
-      "resolved": "https://registry.npmjs.org/mime-db/-/mime-db-1.54.0.tgz",
-      "integrity": "sha512-aU5EJuIN2WDemCcAp2vFBfp/m4EAhWJnUNSSw0ixs7/kXbd6Pg64EmwJkNdFhB8aWt1sH2CTXrLxo/iAGV3oPQ==",
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.6"
-      }
-    },
-    "node_modules/mime-types": {
-      "version": "3.0.1",
-      "resolved": "https://registry.npmjs.org/mime-types/-/mime-types-3.0.1.tgz",
-      "integrity": "sha512-xRc4oEhT6eaBpU1XF7AjpOFD+xQmXNB5OVKwp4tqCuBpHLS/ZbBDrc07mYTDqVMg6PfxUjjNp85O6Cd2Z/5HWA==",
-      "license": "MIT",
-      "dependencies": {
-        "mime-db": "^1.54.0"
-      },
-      "engines": {
-        "node": ">= 0.6"
-      }
-    },
-    "node_modules/minimatch": {
-      "version": "9.0.5",
-      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-9.0.5.tgz",
-      "integrity": "sha512-G6T0ZX48xgozx7587koeX9Ys2NYy6Gmv//P89sEte9V9whIapMNF4idKxnW2QtCcLiTWlb/wfCabAtAFWhhBow==",
-      "dev": true,
-      "license": "ISC",
-      "dependencies": {
-        "brace-expansion": "^2.0.1"
-      },
-      "engines": {
-        "node": ">=16 || 14 >=14.17"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/isaacs"
-      }
-    },
-    "node_modules/ms": {
-      "version": "2.1.3",
-      "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
-      "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
-      "license": "MIT"
-    },
-    "node_modules/natural-compare": {
-      "version": "1.4.0",
-      "resolved": "https://registry.npmjs.org/natural-compare/-/natural-compare-1.4.0.tgz",
-      "integrity": "sha512-OWND8ei3VtNC9h7V60qff3SVobHr996CTwgxubgyQYEpg290h9J0buyECNNJexkFm5sOajh5G116RYA1c8ZMSw==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/negotiator": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/negotiator/-/negotiator-1.0.0.tgz",
-      "integrity": "sha512-8Ofs/AUQh8MaEcrlq5xOX0CQ9ypTF5dl78mjlMNfOK08fzpgTHQRQPBxcPlEtIw0yRpws+Zo/3r+5WRby7u3Gg==",
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.6"
-      }
-    },
-    "node_modules/nice-try": {
-      "version": "1.0.5",
-      "resolved": "https://registry.npmjs.org/nice-try/-/nice-try-1.0.5.tgz",
-      "integrity": "sha512-1nh45deeb5olNY7eX82BkPO7SSxR5SSYJiPTrTdFUVYwAl8CKMA5N9PjTYkHiRjisVcxcQ1HXdLhx2qxxJzLNQ==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/normalize-package-data": {
-      "version": "2.5.0",
-      "resolved": "https://registry.npmjs.org/normalize-package-data/-/normalize-package-data-2.5.0.tgz",
-      "integrity": "sha512-/5CMN3T0R4XTj4DcGaexo+roZSdSFW/0AOOTROrjxzCG1wrWXEsGbRKevjlIL+ZDE4sZlJr5ED4YW0yqmkK+eA==",
-      "dev": true,
-      "license": "BSD-2-Clause",
-      "dependencies": {
-        "hosted-git-info": "^2.1.4",
-        "resolve": "^1.10.0",
-        "semver": "2 || 3 || 4 || 5",
-        "validate-npm-package-license": "^3.0.1"
-      }
-    },
-    "node_modules/normalize-package-data/node_modules/semver": {
-      "version": "5.7.2",
-      "resolved": "https://registry.npmjs.org/semver/-/semver-5.7.2.tgz",
-      "integrity": "sha512-cBznnQ9KjJqU67B52RMC65CMarK2600WFnbkcaiwWq3xy/5haFJlshgnpjovMVJ+Hff49d8GEn0b87C5pDQ10g==",
-      "dev": true,
-      "license": "ISC",
-      "bin": {
-        "semver": "bin/semver"
-      }
-    },
-    "node_modules/npm-run-all": {
-      "version": "4.1.5",
-      "resolved": "https://registry.npmjs.org/npm-run-all/-/npm-run-all-4.1.5.tgz",
-      "integrity": "sha512-Oo82gJDAVcaMdi3nuoKFavkIHBRVqQ1qvMb+9LHk/cF4P6B2m8aP04hGf7oL6wZ9BuGwX1onlLhpuoofSyoQDQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "ansi-styles": "^3.2.1",
-        "chalk": "^2.4.1",
-        "cross-spawn": "^6.0.5",
-        "memorystream": "^0.3.1",
-        "minimatch": "^3.0.4",
-        "pidtree": "^0.3.0",
-        "read-pkg": "^3.0.0",
-        "shell-quote": "^1.6.1",
-        "string.prototype.padend": "^3.0.0"
-      },
-      "bin": {
-        "npm-run-all": "bin/npm-run-all/index.js",
-        "run-p": "bin/run-p/index.js",
-        "run-s": "bin/run-s/index.js"
-      },
-      "engines": {
-        "node": ">= 4"
-      }
-    },
-    "node_modules/npm-run-all/node_modules/ansi-styles": {
-      "version": "3.2.1",
-      "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-3.2.1.tgz",
-      "integrity": "sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "color-convert": "^1.9.0"
-      },
-      "engines": {
-        "node": ">=4"
-      }
-    },
-    "node_modules/npm-run-all/node_modules/brace-expansion": {
-      "version": "1.1.12",
-      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.12.tgz",
-      "integrity": "sha512-9T9UjW3r0UW5c1Q7GTwllptXwhvYmEzFhzMfZ9H7FQWt+uZePjZPjBP/W1ZEyZ1twGWom5/56TF4lPcqjnDHcg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "balanced-match": "^1.0.0",
-        "concat-map": "0.0.1"
-      }
-    },
-    "node_modules/npm-run-all/node_modules/chalk": {
-      "version": "2.4.2",
-      "resolved": "https://registry.npmjs.org/chalk/-/chalk-2.4.2.tgz",
-      "integrity": "sha512-Mti+f9lpJNcwF4tWV8/OrTTtF1gZi+f8FqlyAdouralcFWFQWF2+NgCHShjkCb+IFBLq9buZwE1xckQU4peSuQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "ansi-styles": "^3.2.1",
-        "escape-string-regexp": "^1.0.5",
-        "supports-color": "^5.3.0"
-      },
-      "engines": {
-        "node": ">=4"
-      }
-    },
-    "node_modules/npm-run-all/node_modules/color-convert": {
-      "version": "1.9.3",
-      "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-1.9.3.tgz",
-      "integrity": "sha512-QfAUtd+vFdAtFQcC8CCyYt1fYWxSqAiK2cSD6zDB8N3cpsEBAvRxp9zOGg6G/SHHJYAT88/az/IuDGALsNVbGg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "color-name": "1.1.3"
-      }
-    },
-    "node_modules/npm-run-all/node_modules/color-name": {
-      "version": "1.1.3",
-      "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.3.tgz",
-      "integrity": "sha512-72fSenhMw2HZMTVHeCA9KCmpEIbzWiQsjN+BHcBbS9vr1mtt+vJjPdksIBNUmKAW8TFUDPJK5SUU3QhE9NEXDw==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/npm-run-all/node_modules/cross-spawn": {
-      "version": "6.0.6",
-      "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-6.0.6.tgz",
-      "integrity": "sha512-VqCUuhcd1iB+dsv8gxPttb5iZh/D0iubSP21g36KXdEuf6I5JiioesUVjpCdHV9MZRUfVFlvwtIUyPfxo5trtw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "nice-try": "^1.0.4",
-        "path-key": "^2.0.1",
-        "semver": "^5.5.0",
-        "shebang-command": "^1.2.0",
-        "which": "^1.2.9"
-      },
-      "engines": {
-        "node": ">=4.8"
-      }
-    },
-    "node_modules/npm-run-all/node_modules/escape-string-regexp": {
-      "version": "1.0.5",
-      "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-1.0.5.tgz",
-      "integrity": "sha512-vbRorB5FUQWvla16U8R/qgaFIya2qGzwDrNmCZuYKrbdSUMG6I1ZCGQRefkRVhuOkIGVne7BQ35DSfo1qvJqFg==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=0.8.0"
-      }
-    },
-    "node_modules/npm-run-all/node_modules/has-flag": {
-      "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-3.0.0.tgz",
-      "integrity": "sha512-sKJf1+ceQBr4SMkvQnBDNDtf4TXpVhVGateu0t918bl30FnbE2m4vNLX+VWe/dpjlb+HugGYzW7uQXH98HPEYw==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=4"
-      }
-    },
-    "node_modules/npm-run-all/node_modules/minimatch": {
-      "version": "3.1.2",
-      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz",
-      "integrity": "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==",
-      "dev": true,
-      "license": "ISC",
-      "dependencies": {
-        "brace-expansion": "^1.1.7"
-      },
-      "engines": {
-        "node": "*"
-      }
-    },
-    "node_modules/npm-run-all/node_modules/path-key": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/path-key/-/path-key-2.0.1.tgz",
-      "integrity": "sha512-fEHGKCSmUSDPv4uoj8AlD+joPlq3peND+HRYyxFz4KPw4z926S/b8rIuFs2FYJg3BwsxJf6A9/3eIdLaYC+9Dw==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=4"
-      }
-    },
-    "node_modules/npm-run-all/node_modules/semver": {
-      "version": "5.7.2",
-      "resolved": "https://registry.npmjs.org/semver/-/semver-5.7.2.tgz",
-      "integrity": "sha512-cBznnQ9KjJqU67B52RMC65CMarK2600WFnbkcaiwWq3xy/5haFJlshgnpjovMVJ+Hff49d8GEn0b87C5pDQ10g==",
-      "dev": true,
-      "license": "ISC",
-      "bin": {
-        "semver": "bin/semver"
-      }
-    },
-    "node_modules/npm-run-all/node_modules/shebang-command": {
-      "version": "1.2.0",
-      "resolved": "https://registry.npmjs.org/shebang-command/-/shebang-command-1.2.0.tgz",
-      "integrity": "sha512-EV3L1+UQWGor21OmnvojK36mhg+TyIKDh3iFBKBohr5xeXIhNBcx8oWdgkTEEQ+BEFFYdLRuqMfd5L84N1V5Vg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "shebang-regex": "^1.0.0"
-      },
-      "engines": {
-        "node": ">=0.10.0"
-      }
-    },
-    "node_modules/npm-run-all/node_modules/shebang-regex": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/shebang-regex/-/shebang-regex-1.0.0.tgz",
-      "integrity": "sha512-wpoSFAxys6b2a2wHZ1XpDSgD7N9iVjg29Ph9uV/uaP9Ex/KXlkTZTeddxDPSYQpgvzKLGJke2UU0AzoGCjNIvQ==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=0.10.0"
-      }
-    },
-    "node_modules/npm-run-all/node_modules/supports-color": {
-      "version": "5.5.0",
-      "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-5.5.0.tgz",
-      "integrity": "sha512-QjVjwdXIt408MIiAqCX4oUKsgU2EqAGzs2Ppkm4aQYbjm+ZEWEcW4SfFNTr4uMNZma0ey4f5lgLrkB0aX0QMow==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "has-flag": "^3.0.0"
-      },
-      "engines": {
-        "node": ">=4"
-      }
-    },
-    "node_modules/npm-run-all/node_modules/which": {
-      "version": "1.3.1",
-      "resolved": "https://registry.npmjs.org/which/-/which-1.3.1.tgz",
-      "integrity": "sha512-HxJdYWq1MTIQbJ3nw0cqssHoTNU267KlrDuGZ1WYlxDStUtKUhOaJmh112/TZmHxxUfuJqPXSOm7tDyas0OSIQ==",
-      "dev": true,
-      "license": "ISC",
-      "dependencies": {
-        "isexe": "^2.0.0"
-      },
-      "bin": {
-        "which": "bin/which"
-      }
-    },
-    "node_modules/object-assign": {
-      "version": "4.1.1",
-      "resolved": "https://registry.npmjs.org/object-assign/-/object-assign-4.1.1.tgz",
-      "integrity": "sha512-rJgTQnkUnH1sFw8yT6VSU3zD3sWmu6sZhIseY8VX+GRu3P6F7Fu+JNDoXfklElbLJSnc3FUQHVe4cU5hj+BcUg==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=0.10.0"
-      }
-    },
-    "node_modules/object-inspect": {
-      "version": "1.13.4",
-      "resolved": "https://registry.npmjs.org/object-inspect/-/object-inspect-1.13.4.tgz",
-      "integrity": "sha512-W67iLl4J2EXEGTbfeHCffrjDfitvLANg0UlX3wFUUSTx92KXRFegMHUVgSqE+wvhAbi4WqjGg9czysTV2Epbew==",
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/object-keys": {
-      "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/object-keys/-/object-keys-1.1.1.tgz",
-      "integrity": "sha512-NuAESUOUMrlIXOfHKzD6bpPu3tYt3xvjNdRIQ+FeT0lNb4K8WR70CaDxhuNguS2XG+GjkyMwOzsN5ZktImfhLA==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.4"
-      }
-    },
-    "node_modules/object.assign": {
-      "version": "4.1.7",
-      "resolved": "https://registry.npmjs.org/object.assign/-/object.assign-4.1.7.tgz",
-      "integrity": "sha512-nK28WOo+QIjBkDduTINE4JkF/UJJKyf2EJxvJKfblDpyg0Q+pkOHNTL0Qwy6NP6FhE/EnzV73BxxqcJaXY9anw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "call-bind": "^1.0.8",
-        "call-bound": "^1.0.3",
-        "define-properties": "^1.2.1",
-        "es-object-atoms": "^1.0.0",
-        "has-symbols": "^1.1.0",
-        "object-keys": "^1.1.1"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/on-finished": {
-      "version": "2.4.1",
-      "resolved": "https://registry.npmjs.org/on-finished/-/on-finished-2.4.1.tgz",
-      "integrity": "sha512-oVlzkg3ENAhCk2zdv7IJwd/QUD4z2RxRwpkcGY8psCVcCYZNq4wYnVWALHM+brtuJjePWiYF/ClmuDr8Ch5+kg==",
-      "license": "MIT",
-      "dependencies": {
-        "ee-first": "1.1.1"
-      },
-      "engines": {
-        "node": ">= 0.8"
-      }
-    },
-    "node_modules/once": {
-      "version": "1.4.0",
-      "resolved": "https://registry.npmjs.org/once/-/once-1.4.0.tgz",
-      "integrity": "sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w==",
-      "license": "ISC",
-      "dependencies": {
-        "wrappy": "1"
-      }
-    },
-    "node_modules/optionator": {
-      "version": "0.9.4",
-      "resolved": "https://registry.npmjs.org/optionator/-/optionator-0.9.4.tgz",
-      "integrity": "sha512-6IpQ7mKUxRcZNLIObR0hz7lxsapSSIYNZJwXPGeF0mTVqGKFIXj1DQcMoT22S3ROcLyY/rz0PWaWZ9ayWmad9g==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "deep-is": "^0.1.3",
-        "fast-levenshtein": "^2.0.6",
-        "levn": "^0.4.1",
-        "prelude-ls": "^1.2.1",
-        "type-check": "^0.4.0",
-        "word-wrap": "^1.2.5"
-      },
-      "engines": {
-        "node": ">= 0.8.0"
-      }
-    },
-    "node_modules/own-keys": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/own-keys/-/own-keys-1.0.1.tgz",
-      "integrity": "sha512-qFOyK5PjiWZd+QQIh+1jhdb9LpxTF0qs7Pm8o5QHYZ0M3vKqSqzsZaEB6oWlxZ+q2sJBMI/Ktgd2N5ZwQoRHfg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "get-intrinsic": "^1.2.6",
-        "object-keys": "^1.1.1",
-        "safe-push-apply": "^1.0.0"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/p-limit": {
-      "version": "3.1.0",
-      "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-3.1.0.tgz",
-      "integrity": "sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "yocto-queue": "^0.1.0"
-      },
-      "engines": {
-        "node": ">=10"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/p-locate": {
-      "version": "5.0.0",
-      "resolved": "https://registry.npmjs.org/p-locate/-/p-locate-5.0.0.tgz",
-      "integrity": "sha512-LaNjtRWUBY++zB5nE/NwcaoMylSPk+S+ZHNB1TzdbMJMny6dynpAGt7X/tl/QYq3TIeE6nxHppbo2LGymrG5Pw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "p-limit": "^3.0.2"
-      },
-      "engines": {
-        "node": ">=10"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/parent-module": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/parent-module/-/parent-module-1.0.1.tgz",
-      "integrity": "sha512-GQ2EWRpQV8/o+Aw8YqtfZZPfNRWZYkbidE9k5rpl/hC3vtHHBfGm2Ifi6qWV+coDGkrUKZAxE3Lot5kcsRlh+g==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "callsites": "^3.0.0"
-      },
-      "engines": {
-        "node": ">=6"
-      }
-    },
-    "node_modules/parse-json": {
-      "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/parse-json/-/parse-json-4.0.0.tgz",
-      "integrity": "sha512-aOIos8bujGN93/8Ox/jPLh7RwVnPEysynVFE+fQZyg6jKELEHwzgKdLRFHUgXJL6kylijVSBC4BvN9OmsB48Rw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "error-ex": "^1.3.1",
-        "json-parse-better-errors": "^1.0.1"
-      },
-      "engines": {
-        "node": ">=4"
-      }
-    },
-    "node_modules/parseurl": {
-      "version": "1.3.3",
-      "resolved": "https://registry.npmjs.org/parseurl/-/parseurl-1.3.3.tgz",
-      "integrity": "sha512-CiyeOxFT/JZyN5m0z9PfXw4SCBJ6Sygz1Dpl0wqjlhDEGGBP1GnsUVEL0p63hoG1fcj3fHynXi9NYO4nWOL+qQ==",
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.8"
-      }
-    },
-    "node_modules/path-exists": {
-      "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/path-exists/-/path-exists-4.0.0.tgz",
-      "integrity": "sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/path-key": {
-      "version": "3.1.1",
-      "resolved": "https://registry.npmjs.org/path-key/-/path-key-3.1.1.tgz",
-      "integrity": "sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/path-parse": {
-      "version": "1.0.7",
-      "resolved": "https://registry.npmjs.org/path-parse/-/path-parse-1.0.7.tgz",
-      "integrity": "sha512-LDJzPVEEEPR+y48z93A0Ed0yXb8pAByGWo/k5YYdYgpY2/2EsOsksJrq7lOHxryrVOn1ejG6oAp8ahvOIQD8sw==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/path-to-regexp": {
-      "version": "8.2.0",
-      "resolved": "https://registry.npmjs.org/path-to-regexp/-/path-to-regexp-8.2.0.tgz",
-      "integrity": "sha512-TdrF7fW9Rphjq4RjrW0Kp2AW0Ahwu9sRGTkS6bvDi0SCwZlEZYmcfDbEsTz8RVk0EHIS/Vd1bv3JhG+1xZuAyQ==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=16"
-      }
-    },
-    "node_modules/path-type": {
-      "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/path-type/-/path-type-3.0.0.tgz",
-      "integrity": "sha512-T2ZUsdZFHgA3u4e5PfPbjd7HDDpxPnQb5jN0SrDsjNSuVXHJqtwTnWqG0B1jZrgmJ/7lj1EmVIByWt1gxGkWvg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "pify": "^3.0.0"
-      },
-      "engines": {
-        "node": ">=4"
-      }
-    },
-    "node_modules/picomatch": {
-      "version": "2.3.1",
-      "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.3.1.tgz",
-      "integrity": "sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=8.6"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/jonschlinkert"
-      }
-    },
-    "node_modules/pidtree": {
-      "version": "0.3.1",
-      "resolved": "https://registry.npmjs.org/pidtree/-/pidtree-0.3.1.tgz",
-      "integrity": "sha512-qQbW94hLHEqCg7nhby4yRC7G2+jYHY4Rguc2bjw7Uug4GIJuu1tvf2uHaZv5Q8zdt+WKJ6qK1FOI6amaWUo5FA==",
-      "dev": true,
-      "license": "MIT",
-      "bin": {
-        "pidtree": "bin/pidtree.js"
-      },
-      "engines": {
-        "node": ">=0.10"
-      }
-    },
-    "node_modules/pify": {
-      "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/pify/-/pify-3.0.0.tgz",
-      "integrity": "sha512-C3FsVNH1udSEX48gGX1xfvwTWfsYWj5U+8/uK15BGzIGrKoUpghX8hWZwa/OFnakBiiVNmBvemTJR5mcy7iPcg==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=4"
-      }
-    },
-    "node_modules/pkce-challenge": {
-      "version": "5.0.0",
-      "resolved": "https://registry.npmjs.org/pkce-challenge/-/pkce-challenge-5.0.0.tgz",
-      "integrity": "sha512-ueGLflrrnvwB3xuo/uGob5pd5FN7l0MsLf0Z87o/UQmRtwjvfylfc9MurIxRAWywCYTgrvpXBcqjV4OfCYGCIQ==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=16.20.0"
-      }
-    },
-    "node_modules/possible-typed-array-names": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/possible-typed-array-names/-/possible-typed-array-names-1.1.0.tgz",
-      "integrity": "sha512-/+5VFTchJDoVj3bhoqi6UeymcD00DAwb1nJwamzPvHEszJ4FpF6SNNbUbOS8yI56qHzdV8eK0qEfOSiodkTdxg==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.4"
-      }
-    },
-    "node_modules/prelude-ls": {
-      "version": "1.2.1",
-      "resolved": "https://registry.npmjs.org/prelude-ls/-/prelude-ls-1.2.1.tgz",
-      "integrity": "sha512-vkcDPrRZo1QZLbn5RLGPpg/WmIQ65qoWWhcGKf/b5eplkkarX0m9z8ppCat4mlOqUsWpyNuYgO3VRyrYHSzX5g==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.8.0"
-      }
-    },
-    "node_modules/proxy-addr": {
-      "version": "2.0.7",
-      "resolved": "https://registry.npmjs.org/proxy-addr/-/proxy-addr-2.0.7.tgz",
-      "integrity": "sha512-llQsMLSUDUPT44jdrU/O37qlnifitDP+ZwrmmZcoSKyLKvtZxpyV0n2/bD/N4tBAAZ/gJEdZU7KMraoK1+XYAg==",
-      "license": "MIT",
-      "dependencies": {
-        "forwarded": "0.2.0",
-        "ipaddr.js": "1.9.1"
-      },
-      "engines": {
-        "node": ">= 0.10"
-      }
-    },
-    "node_modules/punycode": {
-      "version": "2.3.1",
-      "resolved": "https://registry.npmjs.org/punycode/-/punycode-2.3.1.tgz",
-      "integrity": "sha512-vYt7UD1U9Wg6138shLtLOvdAu+8DsC/ilFtEVHcH+wydcSpNE20AfSOduf6MkRFahL5FY7X1oU7nKVZFtfq8Fg==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=6"
-      }
-    },
-    "node_modules/qs": {
-      "version": "6.14.0",
-      "resolved": "https://registry.npmjs.org/qs/-/qs-6.14.0.tgz",
-      "integrity": "sha512-YWWTjgABSKcvs/nWBi9PycY/JiPJqOD4JA6o9Sej2AtvSGarXxKC3OQSk4pAarbdQlKAh5D4FCQkJNkW+GAn3w==",
-      "license": "BSD-3-Clause",
-      "dependencies": {
-        "side-channel": "^1.1.0"
-      },
-      "engines": {
-        "node": ">=0.6"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/queue-microtask": {
-      "version": "1.2.3",
-      "resolved": "https://registry.npmjs.org/queue-microtask/-/queue-microtask-1.2.3.tgz",
-      "integrity": "sha512-NuaNSa6flKT5JaSYQzJok04JzTL1CA6aGhv5rfLW3PgqA+M2ChpZQnAC8h8i4ZFkBS8X5RqkDBHA7r4hej3K9A==",
-      "dev": true,
-      "funding": [
-        {
-          "type": "github",
-          "url": "https://github.com/sponsors/feross"
-        },
-        {
-          "type": "patreon",
-          "url": "https://www.patreon.com/feross"
-        },
-        {
-          "type": "consulting",
-          "url": "https://feross.org/support"
-        }
-      ],
-      "license": "MIT"
-    },
-    "node_modules/range-parser": {
-      "version": "1.2.1",
-      "resolved": "https://registry.npmjs.org/range-parser/-/range-parser-1.2.1.tgz",
-      "integrity": "sha512-Hrgsx+orqoygnmhFbKaHE6c296J+HTAQXoxEF6gNupROmmGJRoyzfG3ccAveqCBrwr/2yxQ5BVd/GTl5agOwSg==",
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.6"
-      }
-    },
-    "node_modules/raw-body": {
-      "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/raw-body/-/raw-body-3.0.0.tgz",
-      "integrity": "sha512-RmkhL8CAyCRPXCE28MMH0z2PNWQBNk2Q09ZdxM9IOOXwxwZbN+qbWaatPkdkWIKL2ZVDImrN/pK5HTRz2PcS4g==",
-      "license": "MIT",
-      "dependencies": {
-        "bytes": "3.1.2",
-        "http-errors": "2.0.0",
-        "iconv-lite": "0.6.3",
-        "unpipe": "1.0.0"
-      },
-      "engines": {
-        "node": ">= 0.8"
-      }
-    },
-    "node_modules/read-pkg": {
-      "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/read-pkg/-/read-pkg-3.0.0.tgz",
-      "integrity": "sha512-BLq/cCO9two+lBgiTYNqD6GdtK8s4NpaWrl6/rCO9w0TUS8oJl7cmToOZfRYllKTISY6nt1U7jQ53brmKqY6BA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "load-json-file": "^4.0.0",
-        "normalize-package-data": "^2.3.2",
-        "path-type": "^3.0.0"
-      },
-      "engines": {
-        "node": ">=4"
-      }
-    },
-    "node_modules/reflect.getprototypeof": {
-      "version": "1.0.10",
-      "resolved": "https://registry.npmjs.org/reflect.getprototypeof/-/reflect.getprototypeof-1.0.10.tgz",
-      "integrity": "sha512-00o4I+DVrefhv+nX0ulyi3biSHCPDe+yLv5o/p6d/UVlirijB8E16FtfwSAi4g3tcqrQ4lRAqQSoFEZJehYEcw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "call-bind": "^1.0.8",
-        "define-properties": "^1.2.1",
-        "es-abstract": "^1.23.9",
-        "es-errors": "^1.3.0",
-        "es-object-atoms": "^1.0.0",
-        "get-intrinsic": "^1.2.7",
-        "get-proto": "^1.0.1",
-        "which-builtin-type": "^1.2.1"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/regexp.prototype.flags": {
-      "version": "1.5.4",
-      "resolved": "https://registry.npmjs.org/regexp.prototype.flags/-/regexp.prototype.flags-1.5.4.tgz",
-      "integrity": "sha512-dYqgNSZbDwkaJ2ceRd9ojCGjBq+mOm9LmtXnAnEGyHhN/5R7iDW2TRw3h+o/jCFxus3P2LfWIIiwowAjANm7IA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "call-bind": "^1.0.8",
-        "define-properties": "^1.2.1",
-        "es-errors": "^1.3.0",
-        "get-proto": "^1.0.1",
-        "gopd": "^1.2.0",
-        "set-function-name": "^2.0.2"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/resolve": {
-      "version": "1.22.10",
-      "resolved": "https://registry.npmjs.org/resolve/-/resolve-1.22.10.tgz",
-      "integrity": "sha512-NPRy+/ncIMeDlTAsuqwKIiferiawhefFJtkNSW0qZJEqMEb+qBt/77B/jGeeek+F0uOeN05CDa6HXbbIgtVX4w==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "is-core-module": "^2.16.0",
-        "path-parse": "^1.0.7",
-        "supports-preserve-symlinks-flag": "^1.0.0"
-      },
-      "bin": {
-        "resolve": "bin/resolve"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/resolve-from": {
-      "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/resolve-from/-/resolve-from-4.0.0.tgz",
-      "integrity": "sha512-pb/MYmXstAkysRFx8piNI1tGFNQIFA3vkE3Gq4EuA1dF6gHp/+vgZqsCGJapvy8N3Q+4o7FwvquPJcnZ7RYy4g==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=4"
-      }
-    },
-    "node_modules/reusify": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/reusify/-/reusify-1.1.0.tgz",
-      "integrity": "sha512-g6QUff04oZpHs0eG5p83rFLhHeV00ug/Yf9nZM6fLeUrPguBTkTQOdpAWWspMh55TZfVQDPaN3NQJfbVRAxdIw==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "iojs": ">=1.0.0",
-        "node": ">=0.10.0"
-      }
-    },
-    "node_modules/router": {
-      "version": "2.2.0",
-      "resolved": "https://registry.npmjs.org/router/-/router-2.2.0.tgz",
-      "integrity": "sha512-nLTrUKm2UyiL7rlhapu/Zl45FwNgkZGaCpZbIHajDYgwlJCOzLSk+cIPAnsEqV955GjILJnKbdQC1nVPz+gAYQ==",
-      "license": "MIT",
-      "dependencies": {
-        "debug": "^4.4.0",
-        "depd": "^2.0.0",
-        "is-promise": "^4.0.0",
-        "parseurl": "^1.3.3",
-        "path-to-regexp": "^8.0.0"
-      },
-      "engines": {
-        "node": ">= 18"
-      }
-    },
-    "node_modules/run-parallel": {
-      "version": "1.2.0",
-      "resolved": "https://registry.npmjs.org/run-parallel/-/run-parallel-1.2.0.tgz",
-      "integrity": "sha512-5l4VyZR86LZ/lDxZTR6jqL8AFE2S0IFLMP26AbjsLVADxHdhB/c0GUsH+y39UfCi3dzz8OlQuPmnaJOMoDHQBA==",
-      "dev": true,
-      "funding": [
-        {
-          "type": "github",
-          "url": "https://github.com/sponsors/feross"
-        },
-        {
-          "type": "patreon",
-          "url": "https://www.patreon.com/feross"
-        },
-        {
-          "type": "consulting",
-          "url": "https://feross.org/support"
-        }
-      ],
-      "license": "MIT",
-      "dependencies": {
-        "queue-microtask": "^1.2.2"
-      }
-    },
-    "node_modules/safe-array-concat": {
-      "version": "1.1.3",
-      "resolved": "https://registry.npmjs.org/safe-array-concat/-/safe-array-concat-1.1.3.tgz",
-      "integrity": "sha512-AURm5f0jYEOydBj7VQlVvDrjeFgthDdEF5H1dP+6mNpoXOMo1quQqJ4wvJDyRZ9+pO3kGWoOdmV08cSv2aJV6Q==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "call-bind": "^1.0.8",
-        "call-bound": "^1.0.2",
-        "get-intrinsic": "^1.2.6",
-        "has-symbols": "^1.1.0",
-        "isarray": "^2.0.5"
-      },
-      "engines": {
-        "node": ">=0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/safe-array-concat/node_modules/isarray": {
-      "version": "2.0.5",
-      "resolved": "https://registry.npmjs.org/isarray/-/isarray-2.0.5.tgz",
-      "integrity": "sha512-xHjhDr3cNBK0BzdUJSPXZntQUx/mwMS5Rw4A7lPJ90XGAO6ISP/ePDNuo0vhqOZU+UD5JoodwCAAoZQd3FeAKw==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/safe-push-apply": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/safe-push-apply/-/safe-push-apply-1.0.0.tgz",
-      "integrity": "sha512-iKE9w/Z7xCzUMIZqdBsp6pEQvwuEebH4vdpjcDWnyzaI6yl6O9FHvVpmGelvEHNsoY6wGblkxR6Zty/h00WiSA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "es-errors": "^1.3.0",
-        "isarray": "^2.0.5"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/safe-push-apply/node_modules/isarray": {
-      "version": "2.0.5",
-      "resolved": "https://registry.npmjs.org/isarray/-/isarray-2.0.5.tgz",
-      "integrity": "sha512-xHjhDr3cNBK0BzdUJSPXZntQUx/mwMS5Rw4A7lPJ90XGAO6ISP/ePDNuo0vhqOZU+UD5JoodwCAAoZQd3FeAKw==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/safe-regex-test": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/safe-regex-test/-/safe-regex-test-1.1.0.tgz",
-      "integrity": "sha512-x/+Cz4YrimQxQccJf5mKEbIa1NzeCRNI5Ecl/ekmlYaampdNLPalVyIcCZNNH3MvmqBugV5TMYZXv0ljslUlaw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "call-bound": "^1.0.2",
-        "es-errors": "^1.3.0",
-        "is-regex": "^1.2.1"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/safer-buffer": {
-      "version": "2.1.2",
-      "resolved": "https://registry.npmjs.org/safer-buffer/-/safer-buffer-2.1.2.tgz",
-      "integrity": "sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==",
-      "license": "MIT"
-    },
-    "node_modules/semver": {
-      "version": "7.7.2",
-      "resolved": "https://registry.npmjs.org/semver/-/semver-7.7.2.tgz",
-      "integrity": "sha512-RF0Fw+rO5AMf9MAyaRXI4AV0Ulj5lMHqVxxdSgiVbixSCXoEmmX/jk0CuJw4+3SqroYO9VoUh+HcuJivvtJemA==",
-      "dev": true,
-      "license": "ISC",
-      "bin": {
-        "semver": "bin/semver.js"
-      },
-      "engines": {
-        "node": ">=10"
-      }
-    },
-    "node_modules/send": {
-      "version": "1.2.0",
-      "resolved": "https://registry.npmjs.org/send/-/send-1.2.0.tgz",
-      "integrity": "sha512-uaW0WwXKpL9blXE2o0bRhoL2EGXIrZxQ2ZQ4mgcfoBxdFmQold+qWsD2jLrfZ0trjKL6vOw0j//eAwcALFjKSw==",
-      "license": "MIT",
-      "dependencies": {
-        "debug": "^4.3.5",
-        "encodeurl": "^2.0.0",
-        "escape-html": "^1.0.3",
-        "etag": "^1.8.1",
-        "fresh": "^2.0.0",
-        "http-errors": "^2.0.0",
-        "mime-types": "^3.0.1",
-        "ms": "^2.1.3",
-        "on-finished": "^2.4.1",
-        "range-parser": "^1.2.1",
-        "statuses": "^2.0.1"
-      },
-      "engines": {
-        "node": ">= 18"
-      }
-    },
-    "node_modules/serve-static": {
-      "version": "2.2.0",
-      "resolved": "https://registry.npmjs.org/serve-static/-/serve-static-2.2.0.tgz",
-      "integrity": "sha512-61g9pCh0Vnh7IutZjtLGGpTA355+OPn2TyDv/6ivP2h/AdAVX9azsoxmg2/M6nZeQZNYBEwIcsne1mJd9oQItQ==",
-      "license": "MIT",
-      "dependencies": {
-        "encodeurl": "^2.0.0",
-        "escape-html": "^1.0.3",
-        "parseurl": "^1.3.3",
-        "send": "^1.2.0"
-      },
-      "engines": {
-        "node": ">= 18"
-      }
-    },
-    "node_modules/set-function-length": {
-      "version": "1.2.2",
-      "resolved": "https://registry.npmjs.org/set-function-length/-/set-function-length-1.2.2.tgz",
-      "integrity": "sha512-pgRc4hJ4/sNjWCSS9AmnS40x3bNMDTknHgL5UaMBTMyJnU90EgWh1Rz+MC9eFu4BuN/UwZjKQuY/1v3rM7HMfg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "define-data-property": "^1.1.4",
-        "es-errors": "^1.3.0",
-        "function-bind": "^1.1.2",
-        "get-intrinsic": "^1.2.4",
-        "gopd": "^1.0.1",
-        "has-property-descriptors": "^1.0.2"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      }
-    },
-    "node_modules/set-function-name": {
-      "version": "2.0.2",
-      "resolved": "https://registry.npmjs.org/set-function-name/-/set-function-name-2.0.2.tgz",
-      "integrity": "sha512-7PGFlmtwsEADb0WYyvCMa1t+yke6daIG4Wirafur5kcf+MhUnPms1UeR0CKQdTZD81yESwMHbtn+TR+dMviakQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "define-data-property": "^1.1.4",
-        "es-errors": "^1.3.0",
-        "functions-have-names": "^1.2.3",
-        "has-property-descriptors": "^1.0.2"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      }
-    },
-    "node_modules/set-proto": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/set-proto/-/set-proto-1.0.0.tgz",
-      "integrity": "sha512-RJRdvCo6IAnPdsvP/7m6bsQqNnn1FCBX5ZNtFL98MmFF/4xAIJTIg1YbHW5DC2W5SKZanrC6i4HsJqlajw/dZw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "dunder-proto": "^1.0.1",
-        "es-errors": "^1.3.0",
-        "es-object-atoms": "^1.0.0"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      }
-    },
-    "node_modules/setprototypeof": {
-      "version": "1.2.0",
-      "resolved": "https://registry.npmjs.org/setprototypeof/-/setprototypeof-1.2.0.tgz",
-      "integrity": "sha512-E5LDX7Wrp85Kil5bhZv46j8jOeboKq5JMmYM3gVGdGH8xFpPWXUMsNrlODCrkoxMEeNi/XZIwuRvY4XNwYMJpw==",
-      "license": "ISC"
-    },
-    "node_modules/shebang-command": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/shebang-command/-/shebang-command-2.0.0.tgz",
-      "integrity": "sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA==",
-      "license": "MIT",
-      "dependencies": {
-        "shebang-regex": "^3.0.0"
-      },
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/shebang-regex": {
-      "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/shebang-regex/-/shebang-regex-3.0.0.tgz",
-      "integrity": "sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/shell-quote": {
-      "version": "1.8.3",
-      "resolved": "https://registry.npmjs.org/shell-quote/-/shell-quote-1.8.3.tgz",
-      "integrity": "sha512-ObmnIF4hXNg1BqhnHmgbDETF8dLPCggZWBjkQfhZpbszZnYur5DUljTcCHii5LC3J5E0yeO/1LIMyH+UvHQgyw==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/side-channel": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/side-channel/-/side-channel-1.1.0.tgz",
-      "integrity": "sha512-ZX99e6tRweoUXqR+VBrslhda51Nh5MTQwou5tnUDgbtyM0dBgmhEDtWGP/xbKn6hqfPRHujUNwz5fy/wbbhnpw==",
-      "license": "MIT",
-      "dependencies": {
-        "es-errors": "^1.3.0",
-        "object-inspect": "^1.13.3",
-        "side-channel-list": "^1.0.0",
-        "side-channel-map": "^1.0.1",
-        "side-channel-weakmap": "^1.0.2"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/side-channel-list": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/side-channel-list/-/side-channel-list-1.0.0.tgz",
-      "integrity": "sha512-FCLHtRD/gnpCiCHEiJLOwdmFP+wzCmDEkc9y7NsYxeF4u7Btsn1ZuwgwJGxImImHicJArLP4R0yX4c2KCrMrTA==",
-      "license": "MIT",
-      "dependencies": {
-        "es-errors": "^1.3.0",
-        "object-inspect": "^1.13.3"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/side-channel-map": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/side-channel-map/-/side-channel-map-1.0.1.tgz",
-      "integrity": "sha512-VCjCNfgMsby3tTdo02nbjtM/ewra6jPHmpThenkTYh8pG9ucZ/1P8So4u4FGBek/BjpOVsDCMoLA/iuBKIFXRA==",
-      "license": "MIT",
-      "dependencies": {
-        "call-bound": "^1.0.2",
-        "es-errors": "^1.3.0",
-        "get-intrinsic": "^1.2.5",
-        "object-inspect": "^1.13.3"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/side-channel-weakmap": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/side-channel-weakmap/-/side-channel-weakmap-1.0.2.tgz",
-      "integrity": "sha512-WPS/HvHQTYnHisLo9McqBHOJk2FkHO/tlpvldyrnem4aeQp4hai3gythswg6p01oSoTl58rcpiFAjF2br2Ak2A==",
-      "license": "MIT",
-      "dependencies": {
-        "call-bound": "^1.0.2",
-        "es-errors": "^1.3.0",
-        "get-intrinsic": "^1.2.5",
-        "object-inspect": "^1.13.3",
-        "side-channel-map": "^1.0.1"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/spdx-correct": {
-      "version": "3.2.0",
-      "resolved": "https://registry.npmjs.org/spdx-correct/-/spdx-correct-3.2.0.tgz",
-      "integrity": "sha512-kN9dJbvnySHULIluDHy32WHRUu3Og7B9sbY7tsFLctQkIqnMh3hErYgdMjTYuqmcXX+lK5T1lnUt3G7zNswmZA==",
-      "dev": true,
-      "license": "Apache-2.0",
-      "dependencies": {
-        "spdx-expression-parse": "^3.0.0",
-        "spdx-license-ids": "^3.0.0"
-      }
-    },
-    "node_modules/spdx-exceptions": {
-      "version": "2.5.0",
-      "resolved": "https://registry.npmjs.org/spdx-exceptions/-/spdx-exceptions-2.5.0.tgz",
-      "integrity": "sha512-PiU42r+xO4UbUS1buo3LPJkjlO7430Xn5SVAhdpzzsPHsjbYVflnnFdATgabnLude+Cqu25p6N+g2lw/PFsa4w==",
-      "dev": true,
-      "license": "CC-BY-3.0"
-    },
-    "node_modules/spdx-expression-parse": {
-      "version": "3.0.1",
-      "resolved": "https://registry.npmjs.org/spdx-expression-parse/-/spdx-expression-parse-3.0.1.tgz",
-      "integrity": "sha512-cbqHunsQWnJNE6KhVSMsMeH5H/L9EpymbzqTQ3uLwNCLZ1Q481oWaofqH7nO6V07xlXwY6PhQdQ2IedWx/ZK4Q==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "spdx-exceptions": "^2.1.0",
-        "spdx-license-ids": "^3.0.0"
-      }
-    },
-    "node_modules/spdx-license-ids": {
-      "version": "3.0.21",
-      "resolved": "https://registry.npmjs.org/spdx-license-ids/-/spdx-license-ids-3.0.21.tgz",
-      "integrity": "sha512-Bvg/8F5XephndSK3JffaRqdT+gyhfqIPwDHpX80tJrF8QQRYMo8sNMeaZ2Dp5+jhwKnUmIOyFFQfHRkjJm5nXg==",
-      "dev": true,
-      "license": "CC0-1.0"
-    },
-    "node_modules/statuses": {
-      "version": "2.0.2",
-      "resolved": "https://registry.npmjs.org/statuses/-/statuses-2.0.2.tgz",
-      "integrity": "sha512-DvEy55V3DB7uknRo+4iOGT5fP1slR8wQohVdknigZPMpMstaKJQWhwiYBACJE3Ul2pTnATihhBYnRhZQHGBiRw==",
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.8"
-      }
-    },
-    "node_modules/stop-iteration-iterator": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/stop-iteration-iterator/-/stop-iteration-iterator-1.1.0.tgz",
-      "integrity": "sha512-eLoXW/DHyl62zxY4SCaIgnRhuMr6ri4juEYARS8E6sCEqzKpOiE521Ucofdx+KnDZl5xmvGYaaKCk5FEOxJCoQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "es-errors": "^1.3.0",
-        "internal-slot": "^1.1.0"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      }
-    },
-    "node_modules/string.prototype.padend": {
-      "version": "3.1.6",
-      "resolved": "https://registry.npmjs.org/string.prototype.padend/-/string.prototype.padend-3.1.6.tgz",
-      "integrity": "sha512-XZpspuSB7vJWhvJc9DLSlrXl1mcA2BdoY5jjnS135ydXqLoqhs96JjDtCkjJEQHvfqZIp9hBuBMgI589peyx9Q==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "call-bind": "^1.0.7",
-        "define-properties": "^1.2.1",
-        "es-abstract": "^1.23.2",
-        "es-object-atoms": "^1.0.0"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/string.prototype.trim": {
-      "version": "1.2.10",
-      "resolved": "https://registry.npmjs.org/string.prototype.trim/-/string.prototype.trim-1.2.10.tgz",
-      "integrity": "sha512-Rs66F0P/1kedk5lyYyH9uBzuiI/kNRmwJAR9quK6VOtIpZ2G+hMZd+HQbbv25MgCA6gEffoMZYxlTod4WcdrKA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "call-bind": "^1.0.8",
-        "call-bound": "^1.0.2",
-        "define-data-property": "^1.1.4",
-        "define-properties": "^1.2.1",
-        "es-abstract": "^1.23.5",
-        "es-object-atoms": "^1.0.0",
-        "has-property-descriptors": "^1.0.2"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/string.prototype.trimend": {
-      "version": "1.0.9",
-      "resolved": "https://registry.npmjs.org/string.prototype.trimend/-/string.prototype.trimend-1.0.9.tgz",
-      "integrity": "sha512-G7Ok5C6E/j4SGfyLCloXTrngQIQU3PWtXGst3yM7Bea9FRURf1S42ZHlZZtsNque2FN2PoUhfZXYLNWwEr4dLQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "call-bind": "^1.0.8",
-        "call-bound": "^1.0.2",
-        "define-properties": "^1.2.1",
-        "es-object-atoms": "^1.0.0"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/string.prototype.trimstart": {
-      "version": "1.0.8",
-      "resolved": "https://registry.npmjs.org/string.prototype.trimstart/-/string.prototype.trimstart-1.0.8.tgz",
-      "integrity": "sha512-UXSH262CSZY1tfu3G3Secr6uGLCFVPMhIqHjlgCUtCCcgihYc/xKs9djMTMUOb2j1mVSeU8EU6NWc/iQKU6Gfg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "call-bind": "^1.0.7",
-        "define-properties": "^1.2.1",
-        "es-object-atoms": "^1.0.0"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/strip-bom": {
-      "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/strip-bom/-/strip-bom-3.0.0.tgz",
-      "integrity": "sha512-vavAMRXOgBVNF6nyEEmL3DBK19iRpDcoIwW+swQ+CbGiu7lju6t+JklA1MHweoWtadgt4ISVUsXLyDq34ddcwA==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=4"
-      }
-    },
-    "node_modules/strip-json-comments": {
-      "version": "3.1.1",
-      "resolved": "https://registry.npmjs.org/strip-json-comments/-/strip-json-comments-3.1.1.tgz",
-      "integrity": "sha512-6fPc+R4ihwqP6N/aIv2f1gMH8lOVtWQHoqC4yK6oSDVVocumAsfCqjkXnqiYMhmMwS/mEHLp7Vehlt3ql6lEig==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=8"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/supports-preserve-symlinks-flag": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/supports-preserve-symlinks-flag/-/supports-preserve-symlinks-flag-1.0.0.tgz",
-      "integrity": "sha512-ot0WnXS9fgdkgIcePe6RHNk1WA8+muPa6cSjeR3V8K27q9BB1rTE3R1p7Hv0z1ZyAc8s6Vvv8DIyWf681MAt0w==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/to-regex-range": {
-      "version": "5.0.1",
-      "resolved": "https://registry.npmjs.org/to-regex-range/-/to-regex-range-5.0.1.tgz",
-      "integrity": "sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "is-number": "^7.0.0"
-      },
-      "engines": {
-        "node": ">=8.0"
-      }
-    },
-    "node_modules/toidentifier": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/toidentifier/-/toidentifier-1.0.1.tgz",
-      "integrity": "sha512-o5sSPKEkg/DIQNmH43V0/uerLrpzVedkUh8tGNvaeXpfpuwjKenlSox/2O/BTlZUtEe+JG7s5YhEz608PlAHRA==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=0.6"
-      }
-    },
-    "node_modules/ts-api-utils": {
-      "version": "2.1.0",
-      "resolved": "https://registry.npmjs.org/ts-api-utils/-/ts-api-utils-2.1.0.tgz",
-      "integrity": "sha512-CUgTZL1irw8u29bzrOD/nH85jqyc74D6SshFgujOIA7osm2Rz7dYH77agkx7H4FBNxDq7Cjf+IjaX/8zwFW+ZQ==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=18.12"
-      },
-      "peerDependencies": {
-        "typescript": ">=4.8.4"
-      }
-    },
-    "node_modules/type-check": {
-      "version": "0.4.0",
-      "resolved": "https://registry.npmjs.org/type-check/-/type-check-0.4.0.tgz",
-      "integrity": "sha512-XleUoc9uwGXqjWwXaUTZAmzMcFZ5858QA2vvx1Ur5xIcixXIP+8LnFDgRplU30us6teqdlskFfu+ae4K79Ooew==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "prelude-ls": "^1.2.1"
-      },
-      "engines": {
-        "node": ">= 0.8.0"
-      }
-    },
-    "node_modules/type-is": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/type-is/-/type-is-2.0.1.tgz",
-      "integrity": "sha512-OZs6gsjF4vMp32qrCbiVSkrFmXtG/AZhY3t0iAMrMBiAZyV9oALtXO8hsrHbMXF9x6L3grlFuwW2oAz7cav+Gw==",
-      "license": "MIT",
-      "dependencies": {
-        "content-type": "^1.0.5",
-        "media-typer": "^1.1.0",
-        "mime-types": "^3.0.0"
-      },
-      "engines": {
-        "node": ">= 0.6"
-      }
-    },
-    "node_modules/typed-array-buffer": {
-      "version": "1.0.3",
-      "resolved": "https://registry.npmjs.org/typed-array-buffer/-/typed-array-buffer-1.0.3.tgz",
-      "integrity": "sha512-nAYYwfY3qnzX30IkA6AQZjVbtK6duGontcQm1WSG1MD94YLqK0515GNApXkoxKOWMusVssAHWLh9SeaoefYFGw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "call-bound": "^1.0.3",
-        "es-errors": "^1.3.0",
-        "is-typed-array": "^1.1.14"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      }
-    },
-    "node_modules/typed-array-byte-length": {
-      "version": "1.0.3",
-      "resolved": "https://registry.npmjs.org/typed-array-byte-length/-/typed-array-byte-length-1.0.3.tgz",
-      "integrity": "sha512-BaXgOuIxz8n8pIq3e7Atg/7s+DpiYrxn4vdot3w9KbnBhcRQq6o3xemQdIfynqSeXeDrF32x+WvfzmOjPiY9lg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "call-bind": "^1.0.8",
-        "for-each": "^0.3.3",
-        "gopd": "^1.2.0",
-        "has-proto": "^1.2.0",
-        "is-typed-array": "^1.1.14"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/typed-array-byte-offset": {
-      "version": "1.0.4",
-      "resolved": "https://registry.npmjs.org/typed-array-byte-offset/-/typed-array-byte-offset-1.0.4.tgz",
-      "integrity": "sha512-bTlAFB/FBYMcuX81gbL4OcpH5PmlFHqlCCpAl8AlEzMz5k53oNDvN8p1PNOWLEmI2x4orp3raOFB51tv9X+MFQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "available-typed-arrays": "^1.0.7",
-        "call-bind": "^1.0.8",
-        "for-each": "^0.3.3",
-        "gopd": "^1.2.0",
-        "has-proto": "^1.2.0",
-        "is-typed-array": "^1.1.15",
-        "reflect.getprototypeof": "^1.0.9"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/typed-array-length": {
-      "version": "1.0.7",
-      "resolved": "https://registry.npmjs.org/typed-array-length/-/typed-array-length-1.0.7.tgz",
-      "integrity": "sha512-3KS2b+kL7fsuk/eJZ7EQdnEmQoaho/r6KUef7hxvltNA5DR8NAUM+8wJMbJyZ4G9/7i3v5zPBIMN5aybAh2/Jg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "call-bind": "^1.0.7",
-        "for-each": "^0.3.3",
-        "gopd": "^1.0.1",
-        "is-typed-array": "^1.1.13",
-        "possible-typed-array-names": "^1.0.0",
-        "reflect.getprototypeof": "^1.0.6"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/typescript": {
-      "version": "5.8.3",
-      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.8.3.tgz",
-      "integrity": "sha512-p1diW6TqL9L07nNxvRMM7hMMw4c5XOo/1ibL4aAIGmSAt9slTE1Xgw5KWuof2uTOvCg9BY7ZRi+GaF+7sfgPeQ==",
-      "dev": true,
-      "license": "Apache-2.0",
-      "bin": {
-        "tsc": "bin/tsc",
-        "tsserver": "bin/tsserver"
-      },
-      "engines": {
-        "node": ">=14.17"
-      }
-    },
-    "node_modules/unbox-primitive": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/unbox-primitive/-/unbox-primitive-1.1.0.tgz",
-      "integrity": "sha512-nWJ91DjeOkej/TA8pXQ3myruKpKEYgqvpw9lz4OPHj/NWFNluYrjbz9j01CJ8yKQd2g4jFoOkINCTW2I5LEEyw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "call-bound": "^1.0.3",
-        "has-bigints": "^1.0.2",
-        "has-symbols": "^1.1.0",
-        "which-boxed-primitive": "^1.1.1"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/undici-types": {
-      "version": "6.21.0",
-      "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-6.21.0.tgz",
-      "integrity": "sha512-iwDZqg0QAGrg9Rav5H4n0M64c3mkR59cJ6wQp+7C4nI0gsmExaedaYLNO44eT4AtBBwjbTiGPMlt2Md0T9H9JQ==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/unpipe": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/unpipe/-/unpipe-1.0.0.tgz",
-      "integrity": "sha512-pjy2bYhSsufwWlKwPc+l3cN7+wuJlK6uz0YdJEOlQDbl6jo/YlPi4mb8agUkVC8BF7V8NuzeyPNqRksA3hztKQ==",
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.8"
-      }
-    },
-    "node_modules/uri-js": {
-      "version": "4.4.1",
-      "resolved": "https://registry.npmjs.org/uri-js/-/uri-js-4.4.1.tgz",
-      "integrity": "sha512-7rKUyy33Q1yc98pQ1DAmLtwX109F7TIfWlW1Ydo8Wl1ii1SeHieeh0HHfPeL2fMXK6z0s8ecKs9frCuLJvndBg==",
-      "license": "BSD-2-Clause",
-      "dependencies": {
-        "punycode": "^2.1.0"
-      }
-    },
-    "node_modules/validate-npm-package-license": {
-      "version": "3.0.4",
-      "resolved": "https://registry.npmjs.org/validate-npm-package-license/-/validate-npm-package-license-3.0.4.tgz",
-      "integrity": "sha512-DpKm2Ui/xN7/HQKCtpZxoRWBhZ9Z0kqtygG8XCgNQ8ZlDnxuQmWhj566j8fN4Cu3/JmbhsDo7fcAJq4s9h27Ew==",
-      "dev": true,
-      "license": "Apache-2.0",
-      "dependencies": {
-        "spdx-correct": "^3.0.0",
-        "spdx-expression-parse": "^3.0.0"
-      }
-    },
-    "node_modules/vary": {
-      "version": "1.1.2",
-      "resolved": "https://registry.npmjs.org/vary/-/vary-1.1.2.tgz",
-      "integrity": "sha512-BNGbWLfd0eUPabhkXUVm0j8uuvREyTh5ovRa/dyow/BqAbZJyC+5fU+IzQOzmAKzYqYRAISoRhdQr3eIZ/PXqg==",
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.8"
-      }
-    },
-    "node_modules/which": {
-      "version": "2.0.2",
-      "resolved": "https://registry.npmjs.org/which/-/which-2.0.2.tgz",
-      "integrity": "sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==",
-      "license": "ISC",
-      "dependencies": {
-        "isexe": "^2.0.0"
-      },
-      "bin": {
-        "node-which": "bin/node-which"
-      },
-      "engines": {
-        "node": ">= 8"
-      }
-    },
-    "node_modules/which-boxed-primitive": {
-      "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/which-boxed-primitive/-/which-boxed-primitive-1.1.1.tgz",
-      "integrity": "sha512-TbX3mj8n0odCBFVlY8AxkqcHASw3L60jIuF8jFP78az3C2YhmGvqbHBpAjTRH2/xqYunrJ9g1jSyjCjpoWzIAA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "is-bigint": "^1.1.0",
-        "is-boolean-object": "^1.2.1",
-        "is-number-object": "^1.1.1",
-        "is-string": "^1.1.1",
-        "is-symbol": "^1.1.1"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/which-builtin-type": {
-      "version": "1.2.1",
-      "resolved": "https://registry.npmjs.org/which-builtin-type/-/which-builtin-type-1.2.1.tgz",
-      "integrity": "sha512-6iBczoX+kDQ7a3+YJBnh3T+KZRxM/iYNPXicqk66/Qfm1b93iu+yOImkg0zHbj5LNOcNv1TEADiZ0xa34B4q6Q==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "call-bound": "^1.0.2",
-        "function.prototype.name": "^1.1.6",
-        "has-tostringtag": "^1.0.2",
-        "is-async-function": "^2.0.0",
-        "is-date-object": "^1.1.0",
-        "is-finalizationregistry": "^1.1.0",
-        "is-generator-function": "^1.0.10",
-        "is-regex": "^1.2.1",
-        "is-weakref": "^1.0.2",
-        "isarray": "^2.0.5",
-        "which-boxed-primitive": "^1.1.0",
-        "which-collection": "^1.0.2",
-        "which-typed-array": "^1.1.16"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/which-builtin-type/node_modules/isarray": {
-      "version": "2.0.5",
-      "resolved": "https://registry.npmjs.org/isarray/-/isarray-2.0.5.tgz",
-      "integrity": "sha512-xHjhDr3cNBK0BzdUJSPXZntQUx/mwMS5Rw4A7lPJ90XGAO6ISP/ePDNuo0vhqOZU+UD5JoodwCAAoZQd3FeAKw==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/which-collection": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/which-collection/-/which-collection-1.0.2.tgz",
-      "integrity": "sha512-K4jVyjnBdgvc86Y6BkaLZEN933SwYOuBFkdmBu9ZfkcAbdVbpITnDmjvZ/aQjRXQrv5EPkTnD1s39GiiqbngCw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "is-map": "^2.0.3",
-        "is-set": "^2.0.3",
-        "is-weakmap": "^2.0.2",
-        "is-weakset": "^2.0.3"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/which-typed-array": {
-      "version": "1.1.19",
-      "resolved": "https://registry.npmjs.org/which-typed-array/-/which-typed-array-1.1.19.tgz",
-      "integrity": "sha512-rEvr90Bck4WZt9HHFC4DJMsjvu7x+r6bImz0/BrbWb7A2djJ8hnZMrWnHo9F8ssv0OMErasDhftrfROTyqSDrw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "available-typed-arrays": "^1.0.7",
-        "call-bind": "^1.0.8",
-        "call-bound": "^1.0.4",
-        "for-each": "^0.3.5",
-        "get-proto": "^1.0.1",
-        "gopd": "^1.2.0",
-        "has-tostringtag": "^1.0.2"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/word-wrap": {
-      "version": "1.2.5",
-      "resolved": "https://registry.npmjs.org/word-wrap/-/word-wrap-1.2.5.tgz",
-      "integrity": "sha512-BN22B5eaMMI9UMtjrGd5g5eCYPpCPDUy0FJXbYsaT5zYxjFOckS53SQDE3pWkVoWpHXVb3BrYcEN4Twa55B5cA==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=0.10.0"
-      }
-    },
-    "node_modules/wrappy": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz",
-      "integrity": "sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ==",
-      "license": "ISC"
-    },
-    "node_modules/yocto-queue": {
-      "version": "0.1.0",
-      "resolved": "https://registry.npmjs.org/yocto-queue/-/yocto-queue-0.1.0.tgz",
-      "integrity": "sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=10"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/zod": {
-      "version": "3.25.76",
-      "resolved": "https://registry.npmjs.org/zod/-/zod-3.25.76.tgz",
-      "integrity": "sha512-gzUt/qt81nXsFGKIFcC3YnfEAx5NkunCfnDlvuBSSFS02bcXu4Lmea0AFIUwbLWxWPx3d9p8S5QoaujKcNQxcQ==",
-      "license": "MIT",
-      "funding": {
-        "url": "https://github.com/sponsors/colinhacks"
-      }
-    },
-    "node_modules/zod-to-json-schema": {
-      "version": "3.24.6",
-      "resolved": "https://registry.npmjs.org/zod-to-json-schema/-/zod-to-json-schema-3.24.6.tgz",
-      "integrity": "sha512-h/z3PKvcTcTetyjl1fkj79MHNEjm+HpD6NXheWjzOekY7kV+lwDYnHw+ivHkijnCSMz1yJaWBD9vu/Fcmk+vEg==",
-      "license": "ISC",
-      "peerDependencies": {
-        "zod": "^3.24.1"
-      }
-    }
-  }
-}
diff --git a/packages/vscode-ide-companion/package.json b/packages/vscode-ide-companion/package.json
index 2ed5cd21..4cbf9bb1 100644
--- a/packages/vscode-ide-companion/package.json
+++ b/packages/vscode-ide-companion/package.json
@@ -2,7 +2,7 @@
   "name": "gemini-cli-vscode-ide-companion",
   "displayName": "Gemini CLI Companion",
   "description": "Enable Gemini CLI with direct access to your VS Code workspace.",
-  "version": "0.0.1",
+  "version": "0.1.19",
   "publisher": "google",
   "icon": "assets/icon.png",
   "repository": {

From 5349c4d02b9d0887b84c75538456ef88d94ba68d Mon Sep 17 00:00:00 2001
From: gemini-cli-robot <gemini-cli-robot@google.com>
Date: Tue, 12 Aug 2025 18:21:15 +0000
Subject: [PATCH 107/107] chore(release): v0.1.19

---
 package-lock.json                | 10 +++++-----
 package.json                     |  4 ++--
 packages/cli/package.json        |  4 ++--
 packages/core/package.json       |  2 +-
 packages/test-utils/package.json |  2 +-
 5 files changed, 11 insertions(+), 11 deletions(-)

diff --git a/package-lock.json b/package-lock.json
index bcce33b5..c9ca05c4 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@google/gemini-cli",
-  "version": "0.1.18",
+  "version": "0.1.19",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@google/gemini-cli",
-      "version": "0.1.18",
+      "version": "0.1.19",
       "workspaces": [
         "packages/*"
       ],
@@ -11729,7 +11729,7 @@
     },
     "packages/cli": {
       "name": "@google/gemini-cli",
-      "version": "0.1.18",
+      "version": "0.1.19",
       "dependencies": {
         "@google/gemini-cli-core": "file:../core",
         "@google/genai": "1.9.0",
@@ -11933,7 +11933,7 @@
     },
     "packages/core": {
       "name": "@google/gemini-cli-core",
-      "version": "0.1.18",
+      "version": "0.1.19",
       "dependencies": {
         "@google/genai": "1.9.0",
         "@modelcontextprotocol/sdk": "^1.11.0",
@@ -12060,7 +12060,7 @@
     },
     "packages/test-utils": {
       "name": "@google/gemini-cli-test-utils",
-      "version": "0.1.18",
+      "version": "0.1.19",
       "license": "Apache-2.0",
       "devDependencies": {
         "typescript": "^5.3.3"
diff --git a/package.json b/package.json
index 637fc445..754f7ee6 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@google/gemini-cli",
-  "version": "0.1.18",
+  "version": "0.1.19",
   "engines": {
     "node": ">=20.0.0"
   },
@@ -14,7 +14,7 @@
     "url": "git+https://github.com/google-gemini/gemini-cli.git"
   },
   "config": {
-    "sandboxImageUri": "us-docker.pkg.dev/gemini-code-dev/gemini-cli/sandbox:0.1.18"
+    "sandboxImageUri": "us-docker.pkg.dev/gemini-code-dev/gemini-cli/sandbox:0.1.19"
   },
   "scripts": {
     "start": "node scripts/start.js",
diff --git a/packages/cli/package.json b/packages/cli/package.json
index 582705f7..22a3853e 100644
--- a/packages/cli/package.json
+++ b/packages/cli/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@google/gemini-cli",
-  "version": "0.1.18",
+  "version": "0.1.19",
   "description": "Gemini CLI",
   "repository": {
     "type": "git",
@@ -25,7 +25,7 @@
     "dist"
   ],
   "config": {
-    "sandboxImageUri": "us-docker.pkg.dev/gemini-code-dev/gemini-cli/sandbox:0.1.18"
+    "sandboxImageUri": "us-docker.pkg.dev/gemini-code-dev/gemini-cli/sandbox:0.1.19"
   },
   "dependencies": {
     "@google/gemini-cli-core": "file:../core",
diff --git a/packages/core/package.json b/packages/core/package.json
index e78a33cf..e3fb4078 100644
--- a/packages/core/package.json
+++ b/packages/core/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@google/gemini-cli-core",
-  "version": "0.1.18",
+  "version": "0.1.19",
   "description": "Gemini CLI Core",
   "repository": {
     "type": "git",
diff --git a/packages/test-utils/package.json b/packages/test-utils/package.json
index fe401c37..cb93c941 100644
--- a/packages/test-utils/package.json
+++ b/packages/test-utils/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@google/gemini-cli-test-utils",
-  "version": "0.1.18",
+  "version": "0.1.19",
   "private": true,
   "main": "src/index.ts",
   "license": "Apache-2.0",