Add files using upload-large-folder tool

projects/ui/qwen-code/packages/core/src/telemetry/loggers.test.circular.ts

@@ -0,0 +1,125 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Test to verify circular reference handling in telemetry logging
+ */
+
+import { describe, it, expect } from 'vitest';
+import { logToolCall } from './loggers.js';
+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 { MockTool } from '../test-utils/tools.js';
+
+describe('Circular Reference Handling', () => {
+  it('should handle circular references in tool function arguments', () => {
+    // Create a mock config
+    const mockConfig = {
+      getTelemetryEnabled: () => true,
+      getUsageStatisticsEnabled: () => true,
+      getSessionId: () => 'test-session',
+      getModel: () => 'test-model',
+      getEmbeddingModel: () => 'test-embedding',
+      getDebugMode: () => false,
+    } as unknown as Config;
+
+    // Create an object with circular references (similar to HttpsProxyAgent)
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const circularObject: any = {
+      sockets: {},
+      agent: null,
+    };
+    circularObject.agent = circularObject; // Create circular reference
+    circularObject.sockets['test-host'] = [
+      { _httpMessage: { agent: circularObject } },
+    ];
+
+    // Create a mock CompletedToolCall with circular references in function_args
+    const mockRequest: ToolCallRequestInfo = {
+      callId: 'test-call-id',
+      name: 'ReadFile',
+      args: circularObject, // This would cause the original error
+      isClientInitiated: false,
+      prompt_id: 'test-prompt-id',
+    };
+
+    const mockResponse: ToolCallResponseInfo = {
+      callId: 'test-call-id',
+      responseParts: [{ text: 'test result' }],
+      resultDisplay: undefined,
+      error: undefined, // undefined means success
+      errorType: undefined,
+    };
+
+    const tool = new MockTool('mock-tool');
+    const mockCompletedToolCall: CompletedToolCall = {
+      status: 'success',
+      request: mockRequest,
+      response: mockResponse,
+      tool,
+      invocation: tool.build({}),
+      durationMs: 100,
+    };
+
+    // Create a tool call event with circular references in function_args
+    const event = new ToolCallEvent(mockCompletedToolCall);
+
+    // This should not throw an error
+    expect(() => {
+      logToolCall(mockConfig, event);
+    }).not.toThrow();
+  });
+
+  it('should handle normal objects without circular references', () => {
+    const mockConfig = {
+      getTelemetryEnabled: () => true,
+      getUsageStatisticsEnabled: () => true,
+      getSessionId: () => 'test-session',
+      getModel: () => 'test-model',
+      getEmbeddingModel: () => 'test-embedding',
+      getDebugMode: () => false,
+    } as unknown as Config;
+
+    const normalObject = {
+      filePath: '/test/path',
+      options: { encoding: 'utf8' },
+    };
+
+    const mockRequest: ToolCallRequestInfo = {
+      callId: 'test-call-id',
+      name: 'ReadFile',
+      args: normalObject,
+      isClientInitiated: false,
+      prompt_id: 'test-prompt-id',
+    };
+
+    const mockResponse: ToolCallResponseInfo = {
+      callId: 'test-call-id',
+      responseParts: [{ text: 'test result' }],
+      resultDisplay: undefined,
+      error: undefined, // undefined means success
+      errorType: undefined,
+    };
+
+    const tool = new MockTool('mock-tool');
+    const mockCompletedToolCall: CompletedToolCall = {
+      status: 'success',
+      request: mockRequest,
+      response: mockResponse,
+      tool,
+      invocation: tool.build({}),
+      durationMs: 100,
+    };
+
+    const event = new ToolCallEvent(mockCompletedToolCall);
+
+    expect(() => {
+      logToolCall(mockConfig, event);
+    }).not.toThrow();
+  });
+});

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

@@ -0,0 +1,820 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import {
+  AnyToolInvocation,
+  AuthType,
+  CompletedToolCall,
+  ContentGeneratorConfig,
+  EditTool,
+  ErroredToolCall,
+  GeminiClient,
+  ToolConfirmationOutcome,
+  ToolErrorType,
+  ToolRegistry,
+} from '../index.js';
+import { logs } from '@opentelemetry/api-logs';
+import { SemanticAttributes } from '@opentelemetry/semantic-conventions';
+import { Config } from '../config/config.js';
+import {
+  EVENT_API_REQUEST,
+  EVENT_API_RESPONSE,
+  EVENT_CLI_CONFIG,
+  EVENT_TOOL_CALL,
+  EVENT_USER_PROMPT,
+  EVENT_FLASH_FALLBACK,
+} from './constants.js';
+import {
+  logApiRequest,
+  logApiResponse,
+  logCliConfiguration,
+  logUserPrompt,
+  logToolCall,
+  logFlashFallback,
+  logChatCompression,
+} from './loggers.js';
+import { ToolCallDecision } from './tool-call-decision.js';
+import {
+  ApiRequestEvent,
+  ApiResponseEvent,
+  StartSessionEvent,
+  ToolCallEvent,
+  UserPromptEvent,
+  FlashFallbackEvent,
+  makeChatCompressionEvent,
+} from './types.js';
+import * as metrics from './metrics.js';
+import * as sdk from './sdk.js';
+import { vi, describe, beforeEach, it, expect } from 'vitest';
+import { GenerateContentResponseUsageMetadata } from '@google/genai';
+import * as uiTelemetry from './uiTelemetry.js';
+import { makeFakeConfig } from '../test-utils/config.js';
+import { QwenLogger } from './qwen-logger/qwen-logger.js';
+
+describe('loggers', () => {
+  const mockLogger = {
+    emit: vi.fn(),
+  };
+  const mockUiEvent = {
+    addEvent: vi.fn(),
+  };
+
+  beforeEach(() => {
+    vi.spyOn(sdk, 'isTelemetrySdkInitialized').mockReturnValue(true);
+    vi.spyOn(logs, 'getLogger').mockReturnValue(mockLogger);
+    vi.spyOn(uiTelemetry.uiTelemetryService, 'addEvent').mockImplementation(
+      mockUiEvent.addEvent,
+    );
+    vi.useFakeTimers();
+    vi.setSystemTime(new Date('2025-01-01T00:00:00.000Z'));
+  });
+
+  describe('logChatCompression', () => {
+    beforeEach(() => {
+      vi.spyOn(metrics, 'recordChatCompressionMetrics');
+      vi.spyOn(QwenLogger.prototype, 'logChatCompressionEvent');
+    });
+
+    it('logs the chat compression event to QwenLogger', () => {
+      const mockConfig = makeFakeConfig();
+
+      const event = makeChatCompressionEvent({
+        tokens_before: 9001,
+        tokens_after: 9000,
+      });
+
+      logChatCompression(mockConfig, event);
+
+      expect(QwenLogger.prototype.logChatCompressionEvent).toHaveBeenCalledWith(
+        event,
+      );
+    });
+
+    it('records the chat compression event to OTEL', () => {
+      const mockConfig = makeFakeConfig();
+
+      logChatCompression(
+        mockConfig,
+        makeChatCompressionEvent({
+          tokens_before: 9001,
+          tokens_after: 9000,
+        }),
+      );
+
+      expect(metrics.recordChatCompressionMetrics).toHaveBeenCalledWith(
+        mockConfig,
+        { tokens_before: 9001, tokens_after: 9000 },
+      );
+    });
+  });
+
+  describe('logCliConfiguration', () => {
+    it('should log the cli configuration', () => {
+      const mockConfig = {
+        getSessionId: () => 'test-session-id',
+        getModel: () => 'test-model',
+        getEmbeddingModel: () => 'test-embedding-model',
+        getSandbox: () => true,
+        getCoreTools: () => ['ls', 'read-file'],
+        getApprovalMode: () => 'default',
+        getContentGeneratorConfig: () => ({
+          model: 'test-model',
+          apiKey: 'test-api-key',
+          authType: AuthType.USE_VERTEX_AI,
+        }),
+        getTelemetryEnabled: () => true,
+        getUsageStatisticsEnabled: () => true,
+        getTelemetryLogPromptsEnabled: () => true,
+        getFileFilteringRespectGitIgnore: () => true,
+        getFileFilteringAllowBuildArtifacts: () => false,
+        getDebugMode: () => true,
+        getMcpServers: () => ({
+          'test-server': {
+            command: 'test-command',
+          },
+        }),
+        getQuestion: () => 'test-question',
+        getTargetDir: () => 'target-dir',
+        getProxy: () => 'http://test.proxy.com:8080',
+      } as unknown as Config;
+
+      const startSessionEvent = new StartSessionEvent(mockConfig);
+      logCliConfiguration(mockConfig, startSessionEvent);
+
+      expect(mockLogger.emit).toHaveBeenCalledWith({
+        body: 'CLI configuration loaded.',
+        attributes: {
+          'session.id': 'test-session-id',
+          'event.name': EVENT_CLI_CONFIG,
+          'event.timestamp': '2025-01-01T00:00:00.000Z',
+          model: 'test-model',
+          embedding_model: 'test-embedding-model',
+          sandbox_enabled: true,
+          core_tools_enabled: 'ls,read-file',
+          approval_mode: 'default',
+          api_key_enabled: true,
+          vertex_ai_enabled: true,
+          log_user_prompts_enabled: true,
+          file_filtering_respect_git_ignore: true,
+          debug_mode: true,
+          mcp_servers: 'test-server',
+        },
+      });
+    });
+  });
+
+  describe('logUserPrompt', () => {
+    const mockConfig = {
+      getSessionId: () => 'test-session-id',
+      getTelemetryEnabled: () => true,
+      getTelemetryLogPromptsEnabled: () => true,
+      getUsageStatisticsEnabled: () => true,
+    } as unknown as Config;
+
+    it('should log a user prompt', () => {
+      const event = new UserPromptEvent(
+        11,
+        'prompt-id-8',
+        AuthType.USE_VERTEX_AI,
+        'test-prompt',
+      );
+
+      logUserPrompt(mockConfig, event);
+
+      expect(mockLogger.emit).toHaveBeenCalledWith({
+        body: 'User prompt. Length: 11.',
+        attributes: {
+          'session.id': 'test-session-id',
+          'event.name': EVENT_USER_PROMPT,
+          'event.timestamp': '2025-01-01T00:00:00.000Z',
+          prompt_length: 11,
+          prompt: 'test-prompt',
+        },
+      });
+    });
+
+    it('should not log prompt if disabled', () => {
+      const mockConfig = {
+        getSessionId: () => 'test-session-id',
+        getTelemetryEnabled: () => true,
+        getTelemetryLogPromptsEnabled: () => false,
+        getTargetDir: () => 'target-dir',
+        getUsageStatisticsEnabled: () => true,
+      } as unknown as Config;
+      const event = new UserPromptEvent(
+        11,
+        'test-prompt',
+        AuthType.CLOUD_SHELL,
+      );
+
+      logUserPrompt(mockConfig, event);
+
+      expect(mockLogger.emit).toHaveBeenCalledWith({
+        body: 'User prompt. Length: 11.',
+        attributes: {
+          'session.id': 'test-session-id',
+          'event.name': EVENT_USER_PROMPT,
+          'event.timestamp': '2025-01-01T00:00:00.000Z',
+          prompt_length: 11,
+        },
+      });
+    });
+  });
+
+  describe('logApiResponse', () => {
+    const mockConfig = {
+      getSessionId: () => 'test-session-id',
+      getTargetDir: () => 'target-dir',
+      getUsageStatisticsEnabled: () => true,
+      getTelemetryEnabled: () => true,
+      getTelemetryLogPromptsEnabled: () => true,
+    } as Config;
+
+    const mockMetrics = {
+      recordApiResponseMetrics: vi.fn(),
+      recordTokenUsageMetrics: vi.fn(),
+    };
+
+    beforeEach(() => {
+      vi.spyOn(metrics, 'recordApiResponseMetrics').mockImplementation(
+        mockMetrics.recordApiResponseMetrics,
+      );
+      vi.spyOn(metrics, 'recordTokenUsageMetrics').mockImplementation(
+        mockMetrics.recordTokenUsageMetrics,
+      );
+    });
+
+    it('should log an API response with all fields', () => {
+      const usageData: GenerateContentResponseUsageMetadata = {
+        promptTokenCount: 17,
+        candidatesTokenCount: 50,
+        cachedContentTokenCount: 10,
+        thoughtsTokenCount: 5,
+        toolUsePromptTokenCount: 2,
+      };
+      const event = new ApiResponseEvent(
+        'test-response-id',
+        'test-model',
+        100,
+        'prompt-id-1',
+        AuthType.LOGIN_WITH_GOOGLE,
+        usageData,
+        'test-response',
+      );
+
+      logApiResponse(mockConfig, event);
+
+      expect(mockLogger.emit).toHaveBeenCalledWith({
+        body: 'API response from test-model. Status: 200. Duration: 100ms.',
+        attributes: {
+          'session.id': 'test-session-id',
+          'event.name': EVENT_API_RESPONSE,
+          'event.timestamp': '2025-01-01T00:00:00.000Z',
+          [SemanticAttributes.HTTP_STATUS_CODE]: 200,
+          response_id: 'test-response-id',
+          model: 'test-model',
+          status_code: 200,
+          duration_ms: 100,
+          input_token_count: 17,
+          output_token_count: 50,
+          cached_content_token_count: 10,
+          thoughts_token_count: 5,
+          tool_token_count: 2,
+          total_token_count: 0,
+          response_text: 'test-response',
+          prompt_id: 'prompt-id-1',
+          auth_type: 'oauth-personal',
+        },
+      });
+
+      expect(mockMetrics.recordApiResponseMetrics).toHaveBeenCalledWith(
+        mockConfig,
+        'test-model',
+        100,
+        200,
+        undefined,
+      );
+
+      expect(mockMetrics.recordTokenUsageMetrics).toHaveBeenCalledWith(
+        mockConfig,
+        'test-model',
+        50,
+        'output',
+      );
+
+      expect(mockUiEvent.addEvent).toHaveBeenCalledWith({
+        ...event,
+        'event.name': EVENT_API_RESPONSE,
+        'event.timestamp': '2025-01-01T00:00:00.000Z',
+      });
+    });
+
+    it('should log an API response with an error', () => {
+      const usageData: GenerateContentResponseUsageMetadata = {
+        promptTokenCount: 17,
+        candidatesTokenCount: 50,
+        cachedContentTokenCount: 10,
+        thoughtsTokenCount: 5,
+        toolUsePromptTokenCount: 2,
+      };
+      const event = new ApiResponseEvent(
+        'test-response-id-2',
+        'test-model',
+        100,
+        'prompt-id-1',
+        AuthType.USE_GEMINI,
+        usageData,
+        'test-response',
+        'test-error',
+      );
+
+      logApiResponse(mockConfig, event);
+
+      expect(mockLogger.emit).toHaveBeenCalledWith({
+        body: 'API response from test-model. Status: 200. Duration: 100ms.',
+        attributes: {
+          'session.id': 'test-session-id',
+          ...event,
+          'event.name': EVENT_API_RESPONSE,
+          'event.timestamp': '2025-01-01T00:00:00.000Z',
+          'error.message': 'test-error',
+        },
+      });
+
+      expect(mockUiEvent.addEvent).toHaveBeenCalledWith({
+        ...event,
+        'event.name': EVENT_API_RESPONSE,
+        'event.timestamp': '2025-01-01T00:00:00.000Z',
+      });
+    });
+  });
+
+  describe('logApiRequest', () => {
+    const mockConfig = {
+      getSessionId: () => 'test-session-id',
+      getTargetDir: () => 'target-dir',
+      getUsageStatisticsEnabled: () => true,
+      getTelemetryEnabled: () => true,
+      getTelemetryLogPromptsEnabled: () => true,
+    } as Config;
+
+    it('should log an API request with request_text', () => {
+      const event = new ApiRequestEvent(
+        'test-model',
+        'prompt-id-7',
+        'This is a test request',
+      );
+
+      logApiRequest(mockConfig, event);
+
+      expect(mockLogger.emit).toHaveBeenCalledWith({
+        body: 'API request to test-model.',
+        attributes: {
+          'session.id': 'test-session-id',
+          'event.name': EVENT_API_REQUEST,
+          'event.timestamp': '2025-01-01T00:00:00.000Z',
+          model: 'test-model',
+          request_text: 'This is a test request',
+          prompt_id: 'prompt-id-7',
+        },
+      });
+    });
+
+    it('should log an API request without request_text', () => {
+      const event = new ApiRequestEvent('test-model', 'prompt-id-6');
+
+      logApiRequest(mockConfig, event);
+
+      expect(mockLogger.emit).toHaveBeenCalledWith({
+        body: 'API request to test-model.',
+        attributes: {
+          'session.id': 'test-session-id',
+          'event.name': EVENT_API_REQUEST,
+          'event.timestamp': '2025-01-01T00:00:00.000Z',
+          model: 'test-model',
+          prompt_id: 'prompt-id-6',
+        },
+      });
+    });
+  });
+
+  describe('logFlashFallback', () => {
+    const mockConfig = {
+      getSessionId: () => 'test-session-id',
+      getUsageStatisticsEnabled: () => true,
+    } as unknown as Config;
+
+    it('should log flash fallback event', () => {
+      const event = new FlashFallbackEvent(AuthType.USE_VERTEX_AI);
+
+      logFlashFallback(mockConfig, event);
+
+      expect(mockLogger.emit).toHaveBeenCalledWith({
+        body: 'Switching to flash as Fallback.',
+        attributes: {
+          'session.id': 'test-session-id',
+          'event.name': EVENT_FLASH_FALLBACK,
+          'event.timestamp': '2025-01-01T00:00:00.000Z',
+          auth_type: 'vertex-ai',
+        },
+      });
+    });
+  });
+
+  describe('logToolCall', () => {
+    const cfg1 = {
+      getSessionId: () => 'test-session-id',
+      getTargetDir: () => 'target-dir',
+      getGeminiClient: () => mockGeminiClient,
+    } as Config;
+    const cfg2 = {
+      getSessionId: () => 'test-session-id',
+      getTargetDir: () => 'target-dir',
+      getProxy: () => 'http://test.proxy.com:8080',
+      getContentGeneratorConfig: () =>
+        ({ model: 'test-model' }) as ContentGeneratorConfig,
+      getModel: () => 'test-model',
+      getEmbeddingModel: () => 'test-embedding-model',
+      getWorkingDir: () => 'test-working-dir',
+      getSandbox: () => true,
+      getCoreTools: () => ['ls', 'read-file'],
+      getApprovalMode: () => 'default',
+      getTelemetryLogPromptsEnabled: () => true,
+      getFileFilteringRespectGitIgnore: () => true,
+      getFileFilteringAllowBuildArtifacts: () => false,
+      getDebugMode: () => true,
+      getMcpServers: () => ({
+        'test-server': {
+          command: 'test-command',
+        },
+      }),
+      getQuestion: () => 'test-question',
+      getToolRegistry: () => new ToolRegistry(cfg1),
+      getFullContext: () => false,
+      getUserMemory: () => 'user-memory',
+    } as unknown as Config;
+
+    const mockGeminiClient = new GeminiClient(cfg2);
+    const mockConfig = {
+      getSessionId: () => 'test-session-id',
+      getTargetDir: () => 'target-dir',
+      getGeminiClient: () => mockGeminiClient,
+      getUsageStatisticsEnabled: () => true,
+      getTelemetryEnabled: () => true,
+      getTelemetryLogPromptsEnabled: () => true,
+    } as Config;
+
+    const mockMetrics = {
+      recordToolCallMetrics: vi.fn(),
+    };
+
+    beforeEach(() => {
+      vi.spyOn(metrics, 'recordToolCallMetrics').mockImplementation(
+        mockMetrics.recordToolCallMetrics,
+      );
+      mockLogger.emit.mockReset();
+    });
+
+    it('should log a tool call with all fields', () => {
+      const tool = new EditTool(mockConfig);
+      const call: CompletedToolCall = {
+        status: 'success',
+        request: {
+          name: 'test-function',
+          args: {
+            arg1: 'value1',
+            arg2: 2,
+          },
+          callId: 'test-call-id',
+          isClientInitiated: true,
+          prompt_id: 'prompt-id-1',
+        },
+        response: {
+          callId: 'test-call-id',
+          responseParts: 'test-response',
+          resultDisplay: undefined,
+          error: undefined,
+          errorType: undefined,
+        },
+        tool,
+        invocation: {} as AnyToolInvocation,
+        durationMs: 100,
+        outcome: ToolConfirmationOutcome.ProceedOnce,
+      };
+      const event = new ToolCallEvent(call);
+
+      logToolCall(mockConfig, event);
+
+      expect(mockLogger.emit).toHaveBeenCalledWith({
+        body: 'Tool call: test-function. Decision: accept. Success: true. Duration: 100ms.',
+        attributes: {
+          'session.id': 'test-session-id',
+          'event.name': EVENT_TOOL_CALL,
+          'event.timestamp': '2025-01-01T00:00:00.000Z',
+          function_name: 'test-function',
+          function_args: JSON.stringify(
+            {
+              arg1: 'value1',
+              arg2: 2,
+            },
+            null,
+            2,
+          ),
+          duration_ms: 100,
+          success: true,
+          decision: ToolCallDecision.ACCEPT,
+          prompt_id: 'prompt-id-1',
+          tool_type: 'native',
+        },
+      });
+
+      expect(mockMetrics.recordToolCallMetrics).toHaveBeenCalledWith(
+        mockConfig,
+        'test-function',
+        100,
+        true,
+        ToolCallDecision.ACCEPT,
+        'native',
+      );
+
+      expect(mockUiEvent.addEvent).toHaveBeenCalledWith({
+        ...event,
+        'event.name': EVENT_TOOL_CALL,
+        'event.timestamp': '2025-01-01T00:00:00.000Z',
+      });
+    });
+    it('should log a tool call with a reject decision', () => {
+      const call: ErroredToolCall = {
+        status: 'error',
+        request: {
+          name: 'test-function',
+          args: {
+            arg1: 'value1',
+            arg2: 2,
+          },
+          callId: 'test-call-id',
+          isClientInitiated: true,
+          prompt_id: 'prompt-id-2',
+        },
+        response: {
+          callId: 'test-call-id',
+          responseParts: 'test-response',
+          resultDisplay: undefined,
+          error: undefined,
+          errorType: undefined,
+        },
+        durationMs: 100,
+        outcome: ToolConfirmationOutcome.Cancel,
+      };
+      const event = new ToolCallEvent(call);
+
+      logToolCall(mockConfig, event);
+
+      expect(mockLogger.emit).toHaveBeenCalledWith({
+        body: 'Tool call: test-function. Decision: reject. Success: false. Duration: 100ms.',
+        attributes: {
+          'session.id': 'test-session-id',
+          'event.name': EVENT_TOOL_CALL,
+          'event.timestamp': '2025-01-01T00:00:00.000Z',
+          function_name: 'test-function',
+          function_args: JSON.stringify(
+            {
+              arg1: 'value1',
+              arg2: 2,
+            },
+            null,
+            2,
+          ),
+          duration_ms: 100,
+          success: false,
+          decision: ToolCallDecision.REJECT,
+          prompt_id: 'prompt-id-2',
+          tool_type: 'native',
+        },
+      });
+
+      expect(mockMetrics.recordToolCallMetrics).toHaveBeenCalledWith(
+        mockConfig,
+        'test-function',
+        100,
+        false,
+        ToolCallDecision.REJECT,
+        'native',
+      );
+
+      expect(mockUiEvent.addEvent).toHaveBeenCalledWith({
+        ...event,
+        'event.name': EVENT_TOOL_CALL,
+        'event.timestamp': '2025-01-01T00:00:00.000Z',
+      });
+    });
+
+    it('should log a tool call with a modify decision', () => {
+      const call: CompletedToolCall = {
+        status: 'success',
+        request: {
+          name: 'test-function',
+          args: {
+            arg1: 'value1',
+            arg2: 2,
+          },
+          callId: 'test-call-id',
+          isClientInitiated: true,
+          prompt_id: 'prompt-id-3',
+        },
+        response: {
+          callId: 'test-call-id',
+          responseParts: 'test-response',
+          resultDisplay: undefined,
+          error: undefined,
+          errorType: undefined,
+        },
+        outcome: ToolConfirmationOutcome.ModifyWithEditor,
+        tool: new EditTool(mockConfig),
+        invocation: {} as AnyToolInvocation,
+        durationMs: 100,
+      };
+      const event = new ToolCallEvent(call);
+
+      logToolCall(mockConfig, event);
+
+      expect(mockLogger.emit).toHaveBeenCalledWith({
+        body: 'Tool call: test-function. Decision: modify. Success: true. Duration: 100ms.',
+        attributes: {
+          'session.id': 'test-session-id',
+          'event.name': EVENT_TOOL_CALL,
+          'event.timestamp': '2025-01-01T00:00:00.000Z',
+          function_name: 'test-function',
+          function_args: JSON.stringify(
+            {
+              arg1: 'value1',
+              arg2: 2,
+            },
+            null,
+            2,
+          ),
+          duration_ms: 100,
+          success: true,
+          decision: ToolCallDecision.MODIFY,
+          prompt_id: 'prompt-id-3',
+          tool_type: 'native',
+        },
+      });
+
+      expect(mockMetrics.recordToolCallMetrics).toHaveBeenCalledWith(
+        mockConfig,
+        'test-function',
+        100,
+        true,
+        ToolCallDecision.MODIFY,
+        'native',
+      );
+
+      expect(mockUiEvent.addEvent).toHaveBeenCalledWith({
+        ...event,
+        'event.name': EVENT_TOOL_CALL,
+        'event.timestamp': '2025-01-01T00:00:00.000Z',
+      });
+    });
+
+    it('should log a tool call without a decision', () => {
+      const call: CompletedToolCall = {
+        status: 'success',
+        request: {
+          name: 'test-function',
+          args: {
+            arg1: 'value1',
+            arg2: 2,
+          },
+          callId: 'test-call-id',
+          isClientInitiated: true,
+          prompt_id: 'prompt-id-4',
+        },
+        response: {
+          callId: 'test-call-id',
+          responseParts: 'test-response',
+          resultDisplay: undefined,
+          error: undefined,
+          errorType: undefined,
+        },
+        tool: new EditTool(mockConfig),
+        invocation: {} as AnyToolInvocation,
+        durationMs: 100,
+      };
+      const event = new ToolCallEvent(call);
+
+      logToolCall(mockConfig, event);
+
+      expect(mockLogger.emit).toHaveBeenCalledWith({
+        body: 'Tool call: test-function. Success: true. Duration: 100ms.',
+        attributes: {
+          'session.id': 'test-session-id',
+          'event.name': EVENT_TOOL_CALL,
+          'event.timestamp': '2025-01-01T00:00:00.000Z',
+          function_name: 'test-function',
+          function_args: JSON.stringify(
+            {
+              arg1: 'value1',
+              arg2: 2,
+            },
+            null,
+            2,
+          ),
+          duration_ms: 100,
+          success: true,
+          prompt_id: 'prompt-id-4',
+          tool_type: 'native',
+        },
+      });
+
+      expect(mockMetrics.recordToolCallMetrics).toHaveBeenCalledWith(
+        mockConfig,
+        'test-function',
+        100,
+        true,
+        undefined,
+        'native',
+      );
+
+      expect(mockUiEvent.addEvent).toHaveBeenCalledWith({
+        ...event,
+        'event.name': EVENT_TOOL_CALL,
+        'event.timestamp': '2025-01-01T00:00:00.000Z',
+      });
+    });
+
+    it('should log a failed tool call with an error', () => {
+      const call: ErroredToolCall = {
+        status: 'error',
+        request: {
+          name: 'test-function',
+          args: {
+            arg1: 'value1',
+            arg2: 2,
+          },
+          callId: 'test-call-id',
+          isClientInitiated: true,
+          prompt_id: 'prompt-id-5',
+        },
+        response: {
+          callId: 'test-call-id',
+          responseParts: 'test-response',
+          resultDisplay: undefined,
+          error: {
+            name: 'test-error-type',
+            message: 'test-error',
+          },
+          errorType: ToolErrorType.UNKNOWN,
+        },
+        durationMs: 100,
+      };
+      const event = new ToolCallEvent(call);
+
+      logToolCall(mockConfig, event);
+
+      expect(mockLogger.emit).toHaveBeenCalledWith({
+        body: 'Tool call: test-function. Success: false. Duration: 100ms.',
+        attributes: {
+          'session.id': 'test-session-id',
+          'event.name': EVENT_TOOL_CALL,
+          'event.timestamp': '2025-01-01T00:00:00.000Z',
+          function_name: 'test-function',
+          function_args: JSON.stringify(
+            {
+              arg1: 'value1',
+              arg2: 2,
+            },
+            null,
+            2,
+          ),
+          duration_ms: 100,
+          success: false,
+          error: 'test-error',
+          'error.message': 'test-error',
+          error_type: ToolErrorType.UNKNOWN,
+          'error.type': ToolErrorType.UNKNOWN,
+          prompt_id: 'prompt-id-5',
+          tool_type: 'native',
+        },
+      });
+
+      expect(mockMetrics.recordToolCallMetrics).toHaveBeenCalledWith(
+        mockConfig,
+        'test-function',
+        100,
+        false,
+        undefined,
+        'native',
+      );
+
+      expect(mockUiEvent.addEvent).toHaveBeenCalledWith({
+        ...event,
+        'event.name': EVENT_TOOL_CALL,
+        'event.timestamp': '2025-01-01T00:00:00.000Z',
+      });
+    });
+  });
+});

projects/ui/qwen-code/packages/core/src/telemetry/loggers.ts

@@ -0,0 +1,506 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { LogAttributes, LogRecord, logs } from '@opentelemetry/api-logs';
+import { SemanticAttributes } from '@opentelemetry/semantic-conventions';
+import { Config } from '../config/config.js';
+import {
+  EVENT_API_ERROR,
+  EVENT_API_REQUEST,
+  EVENT_API_RESPONSE,
+  EVENT_CLI_CONFIG,
+  EVENT_FLASH_FALLBACK,
+  EVENT_IDE_CONNECTION,
+  EVENT_NEXT_SPEAKER_CHECK,
+  EVENT_SLASH_COMMAND,
+  EVENT_TOOL_CALL,
+  EVENT_USER_PROMPT,
+  SERVICE_NAME,
+  EVENT_CHAT_COMPRESSION,
+  EVENT_INVALID_CHUNK,
+  EVENT_CONTENT_RETRY,
+  EVENT_CONTENT_RETRY_FAILURE,
+} from './constants.js';
+import {
+  ApiErrorEvent,
+  ApiRequestEvent,
+  ApiResponseEvent,
+  FlashFallbackEvent,
+  IdeConnectionEvent,
+  KittySequenceOverflowEvent,
+  LoopDetectedEvent,
+  NextSpeakerCheckEvent,
+  SlashCommandEvent,
+  StartSessionEvent,
+  ToolCallEvent,
+  UserPromptEvent,
+  ChatCompressionEvent,
+  InvalidChunkEvent,
+  ContentRetryEvent,
+  ContentRetryFailureEvent,
+} from './types.js';
+import {
+  recordApiErrorMetrics,
+  recordTokenUsageMetrics,
+  recordApiResponseMetrics,
+  recordToolCallMetrics,
+  recordChatCompressionMetrics,
+  recordInvalidChunk,
+  recordContentRetry,
+  recordContentRetryFailure,
+} from './metrics.js';
+import { QwenLogger } from './qwen-logger/qwen-logger.js';
+import { isTelemetrySdkInitialized } from './sdk.js';
+import { uiTelemetryService, UiEvent } from './uiTelemetry.js';
+import { safeJsonStringify } from '../utils/safeJsonStringify.js';
+
+const shouldLogUserPrompts = (config: Config): boolean =>
+  config.getTelemetryLogPromptsEnabled();
+
+function getCommonAttributes(config: Config): LogAttributes {
+  return {
+    'session.id': config.getSessionId(),
+  };
+}
+
+export function logCliConfiguration(
+  config: Config,
+  event: StartSessionEvent,
+): void {
+  QwenLogger.getInstance(config)?.logStartSessionEvent(event);
+  if (!isTelemetrySdkInitialized()) return;
+
+  const attributes: LogAttributes = {
+    ...getCommonAttributes(config),
+    'event.name': EVENT_CLI_CONFIG,
+    'event.timestamp': new Date().toISOString(),
+    model: event.model,
+    embedding_model: event.embedding_model,
+    sandbox_enabled: event.sandbox_enabled,
+    core_tools_enabled: event.core_tools_enabled,
+    approval_mode: event.approval_mode,
+    api_key_enabled: event.api_key_enabled,
+    vertex_ai_enabled: event.vertex_ai_enabled,
+    log_user_prompts_enabled: event.telemetry_log_user_prompts_enabled,
+    file_filtering_respect_git_ignore: event.file_filtering_respect_git_ignore,
+    debug_mode: event.debug_enabled,
+    mcp_servers: event.mcp_servers,
+  };
+
+  const logger = logs.getLogger(SERVICE_NAME);
+  const logRecord: LogRecord = {
+    body: 'CLI configuration loaded.',
+    attributes,
+  };
+  logger.emit(logRecord);
+}
+
+export function logUserPrompt(config: Config, event: UserPromptEvent): void {
+  QwenLogger.getInstance(config)?.logNewPromptEvent(event);
+  if (!isTelemetrySdkInitialized()) return;
+
+  const attributes: LogAttributes = {
+    ...getCommonAttributes(config),
+    'event.name': EVENT_USER_PROMPT,
+    'event.timestamp': new Date().toISOString(),
+    prompt_length: event.prompt_length,
+  };
+
+  if (shouldLogUserPrompts(config)) {
+    attributes['prompt'] = event.prompt;
+  }
+
+  const logger = logs.getLogger(SERVICE_NAME);
+  const logRecord: LogRecord = {
+    body: `User prompt. Length: ${event.prompt_length}.`,
+    attributes,
+  };
+  logger.emit(logRecord);
+}
+
+export function logToolCall(config: Config, event: ToolCallEvent): void {
+  const uiEvent = {
+    ...event,
+    'event.name': EVENT_TOOL_CALL,
+    'event.timestamp': new Date().toISOString(),
+  } as UiEvent;
+  uiTelemetryService.addEvent(uiEvent);
+  QwenLogger.getInstance(config)?.logToolCallEvent(event);
+  if (!isTelemetrySdkInitialized()) return;
+
+  const attributes: LogAttributes = {
+    ...getCommonAttributes(config),
+    ...event,
+    'event.name': EVENT_TOOL_CALL,
+    'event.timestamp': new Date().toISOString(),
+    function_args: safeJsonStringify(event.function_args, 2),
+  };
+  if (event.error) {
+    attributes['error.message'] = event.error;
+    if (event.error_type) {
+      attributes['error.type'] = event.error_type;
+    }
+  }
+
+  const logger = logs.getLogger(SERVICE_NAME);
+  const logRecord: LogRecord = {
+    body: `Tool call: ${event.function_name}${event.decision ? `. Decision: ${event.decision}` : ''}. Success: ${event.success}. Duration: ${event.duration_ms}ms.`,
+    attributes,
+  };
+  logger.emit(logRecord);
+  recordToolCallMetrics(
+    config,
+    event.function_name,
+    event.duration_ms,
+    event.success,
+    event.decision,
+    event.tool_type,
+  );
+}
+
+export function logApiRequest(config: Config, event: ApiRequestEvent): void {
+  // QwenLogger.getInstance(config)?.logApiRequestEvent(event);
+  if (!isTelemetrySdkInitialized()) return;
+
+  const attributes: LogAttributes = {
+    ...getCommonAttributes(config),
+    ...event,
+    'event.name': EVENT_API_REQUEST,
+    'event.timestamp': new Date().toISOString(),
+  };
+
+  const logger = logs.getLogger(SERVICE_NAME);
+  const logRecord: LogRecord = {
+    body: `API request to ${event.model}.`,
+    attributes,
+  };
+  logger.emit(logRecord);
+}
+
+export function logFlashFallback(
+  config: Config,
+  event: FlashFallbackEvent,
+): void {
+  QwenLogger.getInstance(config)?.logFlashFallbackEvent(event);
+  if (!isTelemetrySdkInitialized()) return;
+
+  const attributes: LogAttributes = {
+    ...getCommonAttributes(config),
+    ...event,
+    'event.name': EVENT_FLASH_FALLBACK,
+    'event.timestamp': new Date().toISOString(),
+  };
+
+  const logger = logs.getLogger(SERVICE_NAME);
+  const logRecord: LogRecord = {
+    body: `Switching to flash as Fallback.`,
+    attributes,
+  };
+  logger.emit(logRecord);
+}
+
+export function logApiError(config: Config, event: ApiErrorEvent): void {
+  const uiEvent = {
+    ...event,
+    'event.name': EVENT_API_ERROR,
+    'event.timestamp': new Date().toISOString(),
+  } as UiEvent;
+  uiTelemetryService.addEvent(uiEvent);
+  QwenLogger.getInstance(config)?.logApiErrorEvent(event);
+  if (!isTelemetrySdkInitialized()) return;
+
+  const attributes: LogAttributes = {
+    ...getCommonAttributes(config),
+    ...event,
+    'event.name': EVENT_API_ERROR,
+    'event.timestamp': new Date().toISOString(),
+    ['error.message']: event.error,
+    model_name: event.model,
+    duration: event.duration_ms,
+  };
+
+  if (event.error_type) {
+    attributes['error.type'] = event.error_type;
+  }
+  if (typeof event.status_code === 'number') {
+    attributes[SemanticAttributes.HTTP_STATUS_CODE] = event.status_code;
+  }
+
+  const logger = logs.getLogger(SERVICE_NAME);
+  const logRecord: LogRecord = {
+    body: `API error for ${event.model}. Error: ${event.error}. Duration: ${event.duration_ms}ms.`,
+    attributes,
+  };
+  logger.emit(logRecord);
+  recordApiErrorMetrics(
+    config,
+    event.model,
+    event.duration_ms,
+    event.status_code,
+    event.error_type,
+  );
+}
+
+export function logApiResponse(config: Config, event: ApiResponseEvent): void {
+  const uiEvent = {
+    ...event,
+    'event.name': EVENT_API_RESPONSE,
+    'event.timestamp': new Date().toISOString(),
+  } as UiEvent;
+  uiTelemetryService.addEvent(uiEvent);
+  QwenLogger.getInstance(config)?.logApiResponseEvent(event);
+  if (!isTelemetrySdkInitialized()) return;
+  const attributes: LogAttributes = {
+    ...getCommonAttributes(config),
+    ...event,
+    'event.name': EVENT_API_RESPONSE,
+    'event.timestamp': new Date().toISOString(),
+  };
+  if (event.response_text) {
+    attributes['response_text'] = event.response_text;
+  }
+  if (event.error) {
+    attributes['error.message'] = event.error;
+  } else if (event.status_code) {
+    if (typeof event.status_code === 'number') {
+      attributes[SemanticAttributes.HTTP_STATUS_CODE] = event.status_code;
+    }
+  }
+
+  const logger = logs.getLogger(SERVICE_NAME);
+  const logRecord: LogRecord = {
+    body: `API response from ${event.model}. Status: ${event.status_code || 'N/A'}. Duration: ${event.duration_ms}ms.`,
+    attributes,
+  };
+  logger.emit(logRecord);
+  recordApiResponseMetrics(
+    config,
+    event.model,
+    event.duration_ms,
+    event.status_code,
+    event.error,
+  );
+  recordTokenUsageMetrics(
+    config,
+    event.model,
+    event.input_token_count,
+    'input',
+  );
+  recordTokenUsageMetrics(
+    config,
+    event.model,
+    event.output_token_count,
+    'output',
+  );
+  recordTokenUsageMetrics(
+    config,
+    event.model,
+    event.cached_content_token_count,
+    'cache',
+  );
+  recordTokenUsageMetrics(
+    config,
+    event.model,
+    event.thoughts_token_count,
+    'thought',
+  );
+  recordTokenUsageMetrics(config, event.model, event.tool_token_count, 'tool');
+}
+
+export function logLoopDetected(
+  config: Config,
+  event: LoopDetectedEvent,
+): void {
+  QwenLogger.getInstance(config)?.logLoopDetectedEvent(event);
+  if (!isTelemetrySdkInitialized()) return;
+
+  const attributes: LogAttributes = {
+    ...getCommonAttributes(config),
+    ...event,
+  };
+
+  const logger = logs.getLogger(SERVICE_NAME);
+  const logRecord: LogRecord = {
+    body: `Loop detected. Type: ${event.loop_type}.`,
+    attributes,
+  };
+  logger.emit(logRecord);
+}
+
+export function logNextSpeakerCheck(
+  config: Config,
+  event: NextSpeakerCheckEvent,
+): void {
+  QwenLogger.getInstance(config)?.logNextSpeakerCheck(event);
+  if (!isTelemetrySdkInitialized()) return;
+
+  const attributes: LogAttributes = {
+    ...getCommonAttributes(config),
+    ...event,
+    'event.name': EVENT_NEXT_SPEAKER_CHECK,
+  };
+
+  const logger = logs.getLogger(SERVICE_NAME);
+  const logRecord: LogRecord = {
+    body: `Next speaker check.`,
+    attributes,
+  };
+  logger.emit(logRecord);
+}
+
+export function logSlashCommand(
+  config: Config,
+  event: SlashCommandEvent,
+): void {
+  QwenLogger.getInstance(config)?.logSlashCommandEvent(event);
+  if (!isTelemetrySdkInitialized()) return;
+
+  const attributes: LogAttributes = {
+    ...getCommonAttributes(config),
+    ...event,
+    'event.name': EVENT_SLASH_COMMAND,
+  };
+
+  const logger = logs.getLogger(SERVICE_NAME);
+  const logRecord: LogRecord = {
+    body: `Slash command: ${event.command}.`,
+    attributes,
+  };
+  logger.emit(logRecord);
+}
+
+export function logIdeConnection(
+  config: Config,
+  event: IdeConnectionEvent,
+): void {
+  QwenLogger.getInstance(config)?.logIdeConnectionEvent(event);
+  if (!isTelemetrySdkInitialized()) return;
+
+  const attributes: LogAttributes = {
+    ...getCommonAttributes(config),
+    ...event,
+    'event.name': EVENT_IDE_CONNECTION,
+  };
+
+  const logger = logs.getLogger(SERVICE_NAME);
+  const logRecord: LogRecord = {
+    body: `Ide connection. Type: ${event.connection_type}.`,
+    attributes,
+  };
+  logger.emit(logRecord);
+}
+
+export function logChatCompression(
+  config: Config,
+  event: ChatCompressionEvent,
+): void {
+  QwenLogger.getInstance(config)?.logChatCompressionEvent(event);
+
+  const attributes: LogAttributes = {
+    ...getCommonAttributes(config),
+    ...event,
+    'event.name': EVENT_CHAT_COMPRESSION,
+  };
+
+  const logger = logs.getLogger(SERVICE_NAME);
+  const logRecord: LogRecord = {
+    body: `Chat compression (Saved ${event.tokens_before - event.tokens_after} tokens)`,
+    attributes,
+  };
+  logger.emit(logRecord);
+
+  recordChatCompressionMetrics(config, {
+    tokens_before: event.tokens_before,
+    tokens_after: event.tokens_after,
+  });
+}
+
+export function logKittySequenceOverflow(
+  config: Config,
+  event: KittySequenceOverflowEvent,
+): void {
+  QwenLogger.getInstance(config)?.logKittySequenceOverflowEvent(event);
+  if (!isTelemetrySdkInitialized()) return;
+  const attributes: LogAttributes = {
+    ...getCommonAttributes(config),
+    ...event,
+  };
+  const logger = logs.getLogger(SERVICE_NAME);
+  const logRecord: LogRecord = {
+    body: `Kitty sequence buffer overflow: ${event.sequence_length} bytes`,
+    attributes,
+  };
+  logger.emit(logRecord);
+}
+export function logInvalidChunk(
+  config: Config,
+  event: InvalidChunkEvent,
+): void {
+  QwenLogger.getInstance(config)?.logInvalidChunkEvent(event);
+  if (!isTelemetrySdkInitialized()) return;
+
+  const attributes: LogAttributes = {
+    ...getCommonAttributes(config),
+    'event.name': EVENT_INVALID_CHUNK,
+    'event.timestamp': event['event.timestamp'],
+  };
+
+  if (event.error_message) {
+    attributes['error.message'] = event.error_message;
+  }
+
+  const logger = logs.getLogger(SERVICE_NAME);
+  const logRecord: LogRecord = {
+    body: `Invalid chunk received from stream.`,
+    attributes,
+  };
+  logger.emit(logRecord);
+  recordInvalidChunk(config);
+}
+
+export function logContentRetry(
+  config: Config,
+  event: ContentRetryEvent,
+): void {
+  QwenLogger.getInstance(config)?.logContentRetryEvent(event);
+  if (!isTelemetrySdkInitialized()) return;
+
+  const attributes: LogAttributes = {
+    ...getCommonAttributes(config),
+    ...event,
+    'event.name': EVENT_CONTENT_RETRY,
+  };
+
+  const logger = logs.getLogger(SERVICE_NAME);
+  const logRecord: LogRecord = {
+    body: `Content retry attempt ${event.attempt_number} due to ${event.error_type}.`,
+    attributes,
+  };
+  logger.emit(logRecord);
+  recordContentRetry(config);
+}
+
+export function logContentRetryFailure(
+  config: Config,
+  event: ContentRetryFailureEvent,
+): void {
+  QwenLogger.getInstance(config)?.logContentRetryFailureEvent(event);
+  if (!isTelemetrySdkInitialized()) return;
+
+  const attributes: LogAttributes = {
+    ...getCommonAttributes(config),
+    ...event,
+    'event.name': EVENT_CONTENT_RETRY_FAILURE,
+  };
+
+  const logger = logs.getLogger(SERVICE_NAME);
+  const logRecord: LogRecord = {
+    body: `All content retries failed after ${event.total_attempts} attempts.`,
+    attributes,
+  };
+  logger.emit(logRecord);
+  recordContentRetryFailure(config);
+}

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

@@ -0,0 +1,343 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { describe, it, expect, vi, beforeEach, type Mock } from 'vitest';
+import type {
+  Counter,
+  Meter,
+  Attributes,
+  Context,
+  Histogram,
+} from '@opentelemetry/api';
+import { Config } from '../config/config.js';
+import { FileOperation } from './metrics.js';
+import { makeFakeConfig } from '../test-utils/config.js';
+
+const mockCounterAddFn: Mock<
+  (value: number, attributes?: Attributes, context?: Context) => void
+> = vi.fn();
+const mockHistogramRecordFn: Mock<
+  (value: number, attributes?: Attributes, context?: Context) => void
+> = vi.fn();
+
+const mockCreateCounterFn: Mock<(name: string, options?: unknown) => Counter> =
+  vi.fn();
+const mockCreateHistogramFn: Mock<
+  (name: string, options?: unknown) => Histogram
+> = vi.fn();
+
+const mockCounterInstance: Counter = {
+  add: mockCounterAddFn,
+} as Partial<Counter> as Counter;
+
+const mockHistogramInstance: Histogram = {
+  record: mockHistogramRecordFn,
+} as Partial<Histogram> as Histogram;
+
+const mockMeterInstance: Meter = {
+  createCounter: mockCreateCounterFn.mockReturnValue(mockCounterInstance),
+  createHistogram: mockCreateHistogramFn.mockReturnValue(mockHistogramInstance),
+} as Partial<Meter> as Meter;
+
+function originalOtelMockFactory() {
+  return {
+    metrics: {
+      getMeter: vi.fn(),
+    },
+    ValueType: {
+      INT: 1,
+    },
+    diag: {
+      setLogger: vi.fn(),
+    },
+  };
+}
+
+vi.mock('@opentelemetry/api');
+
+describe('Telemetry Metrics', () => {
+  let initializeMetricsModule: typeof import('./metrics.js').initializeMetrics;
+  let recordTokenUsageMetricsModule: typeof import('./metrics.js').recordTokenUsageMetrics;
+  let recordFileOperationMetricModule: typeof import('./metrics.js').recordFileOperationMetric;
+  let recordChatCompressionMetricsModule: typeof import('./metrics.js').recordChatCompressionMetrics;
+
+  beforeEach(async () => {
+    vi.resetModules();
+    vi.doMock('@opentelemetry/api', () => {
+      const actualApi = originalOtelMockFactory();
+      (actualApi.metrics.getMeter as Mock).mockReturnValue(mockMeterInstance);
+      return actualApi;
+    });
+
+    const metricsJsModule = await import('./metrics.js');
+    initializeMetricsModule = metricsJsModule.initializeMetrics;
+    recordTokenUsageMetricsModule = metricsJsModule.recordTokenUsageMetrics;
+    recordFileOperationMetricModule = metricsJsModule.recordFileOperationMetric;
+    recordChatCompressionMetricsModule =
+      metricsJsModule.recordChatCompressionMetrics;
+
+    const otelApiModule = await import('@opentelemetry/api');
+
+    mockCounterAddFn.mockClear();
+    mockCreateCounterFn.mockClear();
+    mockCreateHistogramFn.mockClear();
+    mockHistogramRecordFn.mockClear();
+    (otelApiModule.metrics.getMeter as Mock).mockClear();
+
+    (otelApiModule.metrics.getMeter as Mock).mockReturnValue(mockMeterInstance);
+    mockCreateCounterFn.mockReturnValue(mockCounterInstance);
+    mockCreateHistogramFn.mockReturnValue(mockHistogramInstance);
+  });
+
+  describe('recordChatCompressionMetrics', () => {
+    it('does not record metrics if not initialized', () => {
+      const lol = makeFakeConfig({});
+
+      recordChatCompressionMetricsModule(lol, {
+        tokens_after: 100,
+        tokens_before: 200,
+      });
+
+      expect(mockCounterAddFn).not.toHaveBeenCalled();
+    });
+
+    it('records token compression with the correct attributes', () => {
+      const config = makeFakeConfig({});
+      initializeMetricsModule(config);
+
+      recordChatCompressionMetricsModule(config, {
+        tokens_after: 100,
+        tokens_before: 200,
+      });
+
+      expect(mockCounterAddFn).toHaveBeenCalledWith(1, {
+        'session.id': 'test-session-id',
+        tokens_after: 100,
+        tokens_before: 200,
+      });
+    });
+  });
+
+  describe('recordTokenUsageMetrics', () => {
+    const mockConfig = {
+      getSessionId: () => 'test-session-id',
+    } as unknown as Config;
+
+    it('should not record metrics if not initialized', () => {
+      recordTokenUsageMetricsModule(mockConfig, 'gemini-pro', 100, 'input');
+      expect(mockCounterAddFn).not.toHaveBeenCalled();
+    });
+
+    it('should record token usage with the correct attributes', () => {
+      initializeMetricsModule(mockConfig);
+      recordTokenUsageMetricsModule(mockConfig, 'gemini-pro', 100, 'input');
+      expect(mockCounterAddFn).toHaveBeenCalledTimes(2);
+      expect(mockCounterAddFn).toHaveBeenNthCalledWith(1, 1, {
+        'session.id': 'test-session-id',
+      });
+      expect(mockCounterAddFn).toHaveBeenNthCalledWith(2, 100, {
+        'session.id': 'test-session-id',
+        model: 'gemini-pro',
+        type: 'input',
+      });
+    });
+
+    it('should record token usage for different types', () => {
+      initializeMetricsModule(mockConfig);
+      mockCounterAddFn.mockClear();
+
+      recordTokenUsageMetricsModule(mockConfig, 'gemini-pro', 50, 'output');
+      expect(mockCounterAddFn).toHaveBeenCalledWith(50, {
+        'session.id': 'test-session-id',
+        model: 'gemini-pro',
+        type: 'output',
+      });
+
+      recordTokenUsageMetricsModule(mockConfig, 'gemini-pro', 25, 'thought');
+      expect(mockCounterAddFn).toHaveBeenCalledWith(25, {
+        'session.id': 'test-session-id',
+        model: 'gemini-pro',
+        type: 'thought',
+      });
+
+      recordTokenUsageMetricsModule(mockConfig, 'gemini-pro', 75, 'cache');
+      expect(mockCounterAddFn).toHaveBeenCalledWith(75, {
+        'session.id': 'test-session-id',
+        model: 'gemini-pro',
+        type: 'cache',
+      });
+
+      recordTokenUsageMetricsModule(mockConfig, 'gemini-pro', 125, 'tool');
+      expect(mockCounterAddFn).toHaveBeenCalledWith(125, {
+        'session.id': 'test-session-id',
+        model: 'gemini-pro',
+        type: 'tool',
+      });
+    });
+
+    it('should handle different models', () => {
+      initializeMetricsModule(mockConfig);
+      mockCounterAddFn.mockClear();
+
+      recordTokenUsageMetricsModule(mockConfig, 'gemini-ultra', 200, 'input');
+      expect(mockCounterAddFn).toHaveBeenCalledWith(200, {
+        'session.id': 'test-session-id',
+        model: 'gemini-ultra',
+        type: 'input',
+      });
+    });
+  });
+
+  describe('recordFileOperationMetric', () => {
+    const mockConfig = {
+      getSessionId: () => 'test-session-id',
+    } as unknown as Config;
+
+    it('should not record metrics if not initialized', () => {
+      recordFileOperationMetricModule(
+        mockConfig,
+        FileOperation.CREATE,
+        10,
+        'text/plain',
+        'txt',
+      );
+      expect(mockCounterAddFn).not.toHaveBeenCalled();
+    });
+
+    it('should record file creation with all attributes', () => {
+      initializeMetricsModule(mockConfig);
+      recordFileOperationMetricModule(
+        mockConfig,
+        FileOperation.CREATE,
+        10,
+        'text/plain',
+        'txt',
+      );
+
+      expect(mockCounterAddFn).toHaveBeenCalledTimes(2);
+      expect(mockCounterAddFn).toHaveBeenNthCalledWith(1, 1, {
+        'session.id': 'test-session-id',
+      });
+      expect(mockCounterAddFn).toHaveBeenNthCalledWith(2, 1, {
+        'session.id': 'test-session-id',
+        operation: FileOperation.CREATE,
+        lines: 10,
+        mimetype: 'text/plain',
+        extension: 'txt',
+      });
+    });
+
+    it('should record file read with minimal attributes', () => {
+      initializeMetricsModule(mockConfig);
+      mockCounterAddFn.mockClear();
+
+      recordFileOperationMetricModule(mockConfig, FileOperation.READ);
+      expect(mockCounterAddFn).toHaveBeenCalledWith(1, {
+        'session.id': 'test-session-id',
+        operation: FileOperation.READ,
+      });
+    });
+
+    it('should record file update with some attributes', () => {
+      initializeMetricsModule(mockConfig);
+      mockCounterAddFn.mockClear();
+
+      recordFileOperationMetricModule(
+        mockConfig,
+        FileOperation.UPDATE,
+        undefined,
+        'application/javascript',
+      );
+      expect(mockCounterAddFn).toHaveBeenCalledWith(1, {
+        'session.id': 'test-session-id',
+        operation: FileOperation.UPDATE,
+        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,
+      });
+    });
+  });
+});

projects/ui/qwen-code/packages/core/src/telemetry/metrics.ts

@@ -0,0 +1,279 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import {
+  metrics,
+  Attributes,
+  ValueType,
+  Meter,
+  Counter,
+  Histogram,
+} from '@opentelemetry/api';
+import {
+  SERVICE_NAME,
+  METRIC_TOOL_CALL_COUNT,
+  METRIC_TOOL_CALL_LATENCY,
+  METRIC_API_REQUEST_COUNT,
+  METRIC_API_REQUEST_LATENCY,
+  METRIC_TOKEN_USAGE,
+  METRIC_SESSION_COUNT,
+  METRIC_FILE_OPERATION_COUNT,
+  EVENT_CHAT_COMPRESSION,
+  METRIC_INVALID_CHUNK_COUNT,
+  METRIC_CONTENT_RETRY_COUNT,
+  METRIC_CONTENT_RETRY_FAILURE_COUNT,
+} from './constants.js';
+import { Config } from '../config/config.js';
+import { DiffStat } from '../tools/tools.js';
+
+export enum FileOperation {
+  CREATE = 'create',
+  READ = 'read',
+  UPDATE = 'update',
+}
+
+let cliMeter: Meter | undefined;
+let toolCallCounter: Counter | undefined;
+let toolCallLatencyHistogram: Histogram | undefined;
+let apiRequestCounter: Counter | undefined;
+let apiRequestLatencyHistogram: Histogram | undefined;
+let tokenUsageCounter: Counter | undefined;
+let fileOperationCounter: Counter | undefined;
+let chatCompressionCounter: Counter | undefined;
+let invalidChunkCounter: Counter | undefined;
+let contentRetryCounter: Counter | undefined;
+let contentRetryFailureCounter: Counter | undefined;
+let isMetricsInitialized = false;
+
+function getCommonAttributes(config: Config): Attributes {
+  return {
+    'session.id': config.getSessionId(),
+  };
+}
+
+export function getMeter(): Meter | undefined {
+  if (!cliMeter) {
+    cliMeter = metrics.getMeter(SERVICE_NAME);
+  }
+  return cliMeter;
+}
+
+export function initializeMetrics(config: Config): void {
+  if (isMetricsInitialized) return;
+
+  const meter = getMeter();
+  if (!meter) return;
+
+  toolCallCounter = meter.createCounter(METRIC_TOOL_CALL_COUNT, {
+    description: 'Counts tool calls, tagged by function name and success.',
+    valueType: ValueType.INT,
+  });
+  toolCallLatencyHistogram = meter.createHistogram(METRIC_TOOL_CALL_LATENCY, {
+    description: 'Latency of tool calls in milliseconds.',
+    unit: 'ms',
+    valueType: ValueType.INT,
+  });
+  apiRequestCounter = meter.createCounter(METRIC_API_REQUEST_COUNT, {
+    description: 'Counts API requests, tagged by model and status.',
+    valueType: ValueType.INT,
+  });
+  apiRequestLatencyHistogram = meter.createHistogram(
+    METRIC_API_REQUEST_LATENCY,
+    {
+      description: 'Latency of API requests in milliseconds.',
+      unit: 'ms',
+      valueType: ValueType.INT,
+    },
+  );
+  tokenUsageCounter = meter.createCounter(METRIC_TOKEN_USAGE, {
+    description: 'Counts the total number of tokens used.',
+    valueType: ValueType.INT,
+  });
+  fileOperationCounter = meter.createCounter(METRIC_FILE_OPERATION_COUNT, {
+    description: 'Counts file operations (create, read, update).',
+    valueType: ValueType.INT,
+  });
+  chatCompressionCounter = meter.createCounter(EVENT_CHAT_COMPRESSION, {
+    description: 'Counts chat compression events.',
+    valueType: ValueType.INT,
+  });
+
+  // New counters for content errors
+  invalidChunkCounter = meter.createCounter(METRIC_INVALID_CHUNK_COUNT, {
+    description: 'Counts invalid chunks received from a stream.',
+    valueType: ValueType.INT,
+  });
+  contentRetryCounter = meter.createCounter(METRIC_CONTENT_RETRY_COUNT, {
+    description: 'Counts retries due to content errors (e.g., empty stream).',
+    valueType: ValueType.INT,
+  });
+  contentRetryFailureCounter = meter.createCounter(
+    METRIC_CONTENT_RETRY_FAILURE_COUNT,
+    {
+      description: 'Counts occurrences of all content retries failing.',
+      valueType: ValueType.INT,
+    },
+  );
+
+  const sessionCounter = meter.createCounter(METRIC_SESSION_COUNT, {
+    description: 'Count of CLI sessions started.',
+    valueType: ValueType.INT,
+  });
+  sessionCounter.add(1, getCommonAttributes(config));
+  isMetricsInitialized = true;
+}
+
+export function recordChatCompressionMetrics(
+  config: Config,
+  args: { tokens_before: number; tokens_after: number },
+) {
+  if (!chatCompressionCounter || !isMetricsInitialized) return;
+  chatCompressionCounter.add(1, {
+    ...getCommonAttributes(config),
+    ...args,
+  });
+}
+
+export function recordToolCallMetrics(
+  config: Config,
+  functionName: string,
+  durationMs: number,
+  success: boolean,
+  decision?: 'accept' | 'reject' | 'modify' | 'auto_accept',
+  tool_type?: 'native' | 'mcp',
+): void {
+  if (!toolCallCounter || !toolCallLatencyHistogram || !isMetricsInitialized)
+    return;
+
+  const metricAttributes: Attributes = {
+    ...getCommonAttributes(config),
+    function_name: functionName,
+    success,
+    decision,
+    tool_type,
+  };
+  toolCallCounter.add(1, metricAttributes);
+  toolCallLatencyHistogram.record(durationMs, {
+    ...getCommonAttributes(config),
+    function_name: functionName,
+  });
+}
+
+export function recordTokenUsageMetrics(
+  config: Config,
+  model: string,
+  tokenCount: number,
+  type: 'input' | 'output' | 'thought' | 'cache' | 'tool',
+): void {
+  if (!tokenUsageCounter || !isMetricsInitialized) return;
+  tokenUsageCounter.add(tokenCount, {
+    ...getCommonAttributes(config),
+    model,
+    type,
+  });
+}
+
+export function recordApiResponseMetrics(
+  config: Config,
+  model: string,
+  durationMs: number,
+  statusCode?: number | string,
+  error?: string,
+): void {
+  if (
+    !apiRequestCounter ||
+    !apiRequestLatencyHistogram ||
+    !isMetricsInitialized
+  )
+    return;
+  const metricAttributes: Attributes = {
+    ...getCommonAttributes(config),
+    model,
+    status_code: statusCode ?? (error ? 'error' : 'ok'),
+  };
+  apiRequestCounter.add(1, metricAttributes);
+  apiRequestLatencyHistogram.record(durationMs, {
+    ...getCommonAttributes(config),
+    model,
+  });
+}
+
+export function recordApiErrorMetrics(
+  config: Config,
+  model: string,
+  durationMs: number,
+  statusCode?: number | string,
+  errorType?: string,
+): void {
+  if (
+    !apiRequestCounter ||
+    !apiRequestLatencyHistogram ||
+    !isMetricsInitialized
+  )
+    return;
+  const metricAttributes: Attributes = {
+    ...getCommonAttributes(config),
+    model,
+    status_code: statusCode ?? 'error',
+    error_type: errorType ?? 'unknown',
+  };
+  apiRequestCounter.add(1, metricAttributes);
+  apiRequestLatencyHistogram.record(durationMs, {
+    ...getCommonAttributes(config),
+    model,
+  });
+}
+
+export function recordFileOperationMetric(
+  config: Config,
+  operation: FileOperation,
+  lines?: number,
+  mimetype?: string,
+  extension?: string,
+  diffStat?: DiffStat,
+): void {
+  if (!fileOperationCounter || !isMetricsInitialized) return;
+  const attributes: Attributes = {
+    ...getCommonAttributes(config),
+    operation,
+  };
+  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);
+}
+
+// --- New Metric Recording Functions ---
+
+/**
+ * Records a metric for when an invalid chunk is received from a stream.
+ */
+export function recordInvalidChunk(config: Config): void {
+  if (!invalidChunkCounter || !isMetricsInitialized) return;
+  invalidChunkCounter.add(1, getCommonAttributes(config));
+}
+
+/**
+ * Records a metric for when a retry is triggered due to a content error.
+ */
+export function recordContentRetry(config: Config): void {
+  if (!contentRetryCounter || !isMetricsInitialized) return;
+  contentRetryCounter.add(1, getCommonAttributes(config));
+}
+
+/**
+ * Records a metric for when all content error retries have failed for a request.
+ */
+export function recordContentRetryFailure(config: Config): void {
+  if (!contentRetryFailureCounter || !isMetricsInitialized) return;
+  contentRetryFailureCounter.add(1, getCommonAttributes(config));
+}

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

@@ -0,0 +1,104 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { Config } from '../config/config.js';
+import { initializeTelemetry, shutdownTelemetry } from './sdk.js';
+import { OTLPTraceExporter } from '@opentelemetry/exporter-trace-otlp-grpc';
+import { OTLPLogExporter } from '@opentelemetry/exporter-logs-otlp-grpc';
+import { OTLPMetricExporter } from '@opentelemetry/exporter-metrics-otlp-grpc';
+import { OTLPTraceExporter as OTLPTraceExporterHttp } from '@opentelemetry/exporter-trace-otlp-http';
+import { OTLPLogExporter as OTLPLogExporterHttp } from '@opentelemetry/exporter-logs-otlp-http';
+import { OTLPMetricExporter as OTLPMetricExporterHttp } from '@opentelemetry/exporter-metrics-otlp-http';
+import { NodeSDK } from '@opentelemetry/sdk-node';
+
+vi.mock('@opentelemetry/exporter-trace-otlp-grpc');
+vi.mock('@opentelemetry/exporter-logs-otlp-grpc');
+vi.mock('@opentelemetry/exporter-metrics-otlp-grpc');
+vi.mock('@opentelemetry/exporter-trace-otlp-http');
+vi.mock('@opentelemetry/exporter-logs-otlp-http');
+vi.mock('@opentelemetry/exporter-metrics-otlp-http');
+vi.mock('@opentelemetry/sdk-node');
+
+describe('Telemetry SDK', () => {
+  let mockConfig: Config;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockConfig = {
+      getTelemetryEnabled: () => true,
+      getTelemetryOtlpEndpoint: () => 'http://localhost:4317',
+      getTelemetryOtlpProtocol: () => 'grpc',
+      getTelemetryOutfile: () => undefined,
+      getDebugMode: () => false,
+      getSessionId: () => 'test-session',
+    } as unknown as Config;
+  });
+
+  afterEach(async () => {
+    await shutdownTelemetry(mockConfig);
+  });
+
+  it('should use gRPC exporters when protocol is grpc', () => {
+    initializeTelemetry(mockConfig);
+
+    expect(OTLPTraceExporter).toHaveBeenCalledWith({
+      url: 'http://localhost:4317',
+      compression: 'gzip',
+    });
+    expect(OTLPLogExporter).toHaveBeenCalledWith({
+      url: 'http://localhost:4317',
+      compression: 'gzip',
+    });
+    expect(OTLPMetricExporter).toHaveBeenCalledWith({
+      url: 'http://localhost:4317',
+      compression: 'gzip',
+    });
+    expect(NodeSDK.prototype.start).toHaveBeenCalled();
+  });
+
+  it('should use HTTP exporters when protocol is http', () => {
+    vi.spyOn(mockConfig, 'getTelemetryEnabled').mockReturnValue(true);
+    vi.spyOn(mockConfig, 'getTelemetryOtlpProtocol').mockReturnValue('http');
+    vi.spyOn(mockConfig, 'getTelemetryOtlpEndpoint').mockReturnValue(
+      'http://localhost:4318',
+    );
+
+    initializeTelemetry(mockConfig);
+
+    expect(OTLPTraceExporterHttp).toHaveBeenCalledWith({
+      url: 'http://localhost:4318/',
+    });
+    expect(OTLPLogExporterHttp).toHaveBeenCalledWith({
+      url: 'http://localhost:4318/',
+    });
+    expect(OTLPMetricExporterHttp).toHaveBeenCalledWith({
+      url: 'http://localhost:4318/',
+    });
+    expect(NodeSDK.prototype.start).toHaveBeenCalled();
+  });
+
+  it('should parse gRPC endpoint correctly', () => {
+    vi.spyOn(mockConfig, 'getTelemetryOtlpEndpoint').mockReturnValue(
+      'https://my-collector.com',
+    );
+    initializeTelemetry(mockConfig);
+    expect(OTLPTraceExporter).toHaveBeenCalledWith(
+      expect.objectContaining({ url: 'https://my-collector.com' }),
+    );
+  });
+
+  it('should parse HTTP endpoint correctly', () => {
+    vi.spyOn(mockConfig, 'getTelemetryOtlpProtocol').mockReturnValue('http');
+    vi.spyOn(mockConfig, 'getTelemetryOtlpEndpoint').mockReturnValue(
+      'https://my-collector.com',
+    );
+    initializeTelemetry(mockConfig);
+    expect(OTLPTraceExporterHttp).toHaveBeenCalledWith(
+      expect.objectContaining({ url: 'https://my-collector.com/' }),
+    );
+  });
+});

projects/ui/qwen-code/packages/core/src/telemetry/sdk.ts

@@ -0,0 +1,193 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { DiagConsoleLogger, DiagLogLevel, diag } from '@opentelemetry/api';
+import { OTLPTraceExporter } from '@opentelemetry/exporter-trace-otlp-grpc';
+import { OTLPLogExporter } from '@opentelemetry/exporter-logs-otlp-grpc';
+import { OTLPMetricExporter } from '@opentelemetry/exporter-metrics-otlp-grpc';
+import { OTLPTraceExporter as OTLPTraceExporterHttp } from '@opentelemetry/exporter-trace-otlp-http';
+import { OTLPLogExporter as OTLPLogExporterHttp } from '@opentelemetry/exporter-logs-otlp-http';
+import { OTLPMetricExporter as OTLPMetricExporterHttp } from '@opentelemetry/exporter-metrics-otlp-http';
+import { CompressionAlgorithm } from '@opentelemetry/otlp-exporter-base';
+import { NodeSDK } from '@opentelemetry/sdk-node';
+import { SemanticResourceAttributes } from '@opentelemetry/semantic-conventions';
+import { resourceFromAttributes } from '@opentelemetry/resources';
+import {
+  BatchSpanProcessor,
+  ConsoleSpanExporter,
+} from '@opentelemetry/sdk-trace-node';
+import {
+  BatchLogRecordProcessor,
+  ConsoleLogRecordExporter,
+} from '@opentelemetry/sdk-logs';
+import {
+  ConsoleMetricExporter,
+  PeriodicExportingMetricReader,
+} from '@opentelemetry/sdk-metrics';
+import { HttpInstrumentation } from '@opentelemetry/instrumentation-http';
+import { Config } from '../config/config.js';
+import { SERVICE_NAME } from './constants.js';
+import { initializeMetrics } from './metrics.js';
+import {
+  FileLogExporter,
+  FileMetricExporter,
+  FileSpanExporter,
+} from './file-exporters.js';
+
+// For troubleshooting, set the log level to DiagLogLevel.DEBUG
+diag.setLogger(new DiagConsoleLogger(), DiagLogLevel.INFO);
+
+let sdk: NodeSDK | undefined;
+let telemetryInitialized = false;
+
+export function isTelemetrySdkInitialized(): boolean {
+  return telemetryInitialized;
+}
+
+function parseOtlpEndpoint(
+  otlpEndpointSetting: string | undefined,
+  protocol: 'grpc' | 'http',
+): string | undefined {
+  if (!otlpEndpointSetting) {
+    return undefined;
+  }
+  // Trim leading/trailing quotes that might come from env variables
+  const trimmedEndpoint = otlpEndpointSetting.replace(/^["']|["']$/g, '');
+
+  try {
+    const url = new URL(trimmedEndpoint);
+    if (protocol === 'grpc') {
+      // OTLP gRPC exporters expect an endpoint in the format scheme://host:port
+      // The `origin` property provides this, stripping any path, query, or hash.
+      return url.origin;
+    }
+    // For http, use the full href.
+    return url.href;
+  } catch (error) {
+    diag.error('Invalid OTLP endpoint URL provided:', trimmedEndpoint, error);
+    return undefined;
+  }
+}
+
+export function initializeTelemetry(config: Config): void {
+  if (telemetryInitialized || !config.getTelemetryEnabled()) {
+    return;
+  }
+
+  const resource = resourceFromAttributes({
+    [SemanticResourceAttributes.SERVICE_NAME]: SERVICE_NAME,
+    [SemanticResourceAttributes.SERVICE_VERSION]: process.version,
+    'session.id': config.getSessionId(),
+  });
+
+  const otlpEndpoint = config.getTelemetryOtlpEndpoint();
+  const otlpProtocol = config.getTelemetryOtlpProtocol();
+  const parsedEndpoint = parseOtlpEndpoint(otlpEndpoint, otlpProtocol);
+  const useOtlp = !!parsedEndpoint;
+  const telemetryOutfile = config.getTelemetryOutfile();
+
+  let spanExporter:
+    | OTLPTraceExporter
+    | OTLPTraceExporterHttp
+    | FileSpanExporter
+    | ConsoleSpanExporter;
+  let logExporter:
+    | OTLPLogExporter
+    | OTLPLogExporterHttp
+    | FileLogExporter
+    | ConsoleLogRecordExporter;
+  let metricReader: PeriodicExportingMetricReader;
+
+  if (useOtlp) {
+    if (otlpProtocol === 'http') {
+      spanExporter = new OTLPTraceExporterHttp({
+        url: parsedEndpoint,
+      });
+      logExporter = new OTLPLogExporterHttp({
+        url: parsedEndpoint,
+      });
+      metricReader = new PeriodicExportingMetricReader({
+        exporter: new OTLPMetricExporterHttp({
+          url: parsedEndpoint,
+        }),
+        exportIntervalMillis: 10000,
+      });
+    } else {
+      // grpc
+      spanExporter = new OTLPTraceExporter({
+        url: parsedEndpoint,
+        compression: CompressionAlgorithm.GZIP,
+      });
+      logExporter = new OTLPLogExporter({
+        url: parsedEndpoint,
+        compression: CompressionAlgorithm.GZIP,
+      });
+      metricReader = new PeriodicExportingMetricReader({
+        exporter: new OTLPMetricExporter({
+          url: parsedEndpoint,
+          compression: CompressionAlgorithm.GZIP,
+        }),
+        exportIntervalMillis: 10000,
+      });
+    }
+  } else if (telemetryOutfile) {
+    spanExporter = new FileSpanExporter(telemetryOutfile);
+    logExporter = new FileLogExporter(telemetryOutfile);
+    metricReader = new PeriodicExportingMetricReader({
+      exporter: new FileMetricExporter(telemetryOutfile),
+      exportIntervalMillis: 10000,
+    });
+  } else {
+    spanExporter = new ConsoleSpanExporter();
+    logExporter = new ConsoleLogRecordExporter();
+    metricReader = new PeriodicExportingMetricReader({
+      exporter: new ConsoleMetricExporter(),
+      exportIntervalMillis: 10000,
+    });
+  }
+
+  sdk = new NodeSDK({
+    resource,
+    spanProcessors: [new BatchSpanProcessor(spanExporter)],
+    logRecordProcessors: [new BatchLogRecordProcessor(logExporter)],
+    metricReader,
+    instrumentations: [new HttpInstrumentation()],
+  });
+
+  try {
+    sdk.start();
+    if (config.getDebugMode()) {
+      console.log('OpenTelemetry SDK started successfully.');
+    }
+    telemetryInitialized = true;
+    initializeMetrics(config);
+  } catch (error) {
+    console.error('Error starting OpenTelemetry SDK:', error);
+  }
+
+  process.on('SIGTERM', () => {
+    shutdownTelemetry(config);
+  });
+  process.on('SIGINT', () => {
+    shutdownTelemetry(config);
+  });
+}
+
+export async function shutdownTelemetry(config: Config): Promise<void> {
+  if (!telemetryInitialized || !sdk) {
+    return;
+  }
+  try {
+    await sdk.shutdown();
+    if (config.getDebugMode()) {
+      console.log('OpenTelemetry SDK shut down successfully.');
+    }
+  } catch (error) {
+    console.error('Error shutting down SDK:', error);
+  } finally {
+    telemetryInitialized = false;
+  }
+}

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

@@ -0,0 +1,64 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import {
+  initializeTelemetry,
+  shutdownTelemetry,
+  isTelemetrySdkInitialized,
+} from './sdk.js';
+import { Config } from '../config/config.js';
+import { NodeSDK } from '@opentelemetry/sdk-node';
+
+vi.mock('@opentelemetry/sdk-node');
+vi.mock('../config/config.js');
+
+describe('telemetry', () => {
+  let mockConfig: Config;
+  let mockNodeSdk: NodeSDK;
+
+  beforeEach(() => {
+    vi.resetAllMocks();
+
+    mockConfig = new Config({
+      sessionId: 'test-session-id',
+      model: 'test-model',
+      targetDir: '/test/dir',
+      debugMode: false,
+      cwd: '/test/dir',
+    });
+    vi.spyOn(mockConfig, 'getTelemetryEnabled').mockReturnValue(true);
+    vi.spyOn(mockConfig, 'getTelemetryOtlpEndpoint').mockReturnValue(
+      'http://localhost:4317',
+    );
+    vi.spyOn(mockConfig, 'getSessionId').mockReturnValue('test-session-id');
+    mockNodeSdk = {
+      start: vi.fn(),
+      shutdown: vi.fn().mockResolvedValue(undefined),
+    } as unknown as NodeSDK;
+    vi.mocked(NodeSDK).mockImplementation(() => mockNodeSdk);
+  });
+
+  afterEach(async () => {
+    // Ensure we shut down telemetry even if a test fails.
+    if (isTelemetrySdkInitialized()) {
+      await shutdownTelemetry(mockConfig);
+    }
+  });
+
+  it('should initialize the telemetry service', () => {
+    initializeTelemetry(mockConfig);
+    expect(NodeSDK).toHaveBeenCalled();
+    expect(mockNodeSdk.start).toHaveBeenCalled();
+  });
+
+  it('should shutdown the telemetry service', async () => {
+    initializeTelemetry(mockConfig);
+    await shutdownTelemetry(mockConfig);
+
+    expect(mockNodeSdk.shutdown).toHaveBeenCalled();
+  });
+});

projects/ui/qwen-code/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;
+  }
+}

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

@@ -0,0 +1,464 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { GenerateContentResponseUsageMetadata } from '@google/genai';
+import { Config } from '../config/config.js';
+import { CompletedToolCall } from '../core/coreToolScheduler.js';
+import { DiscoveredMCPTool } from '../tools/mcp-tool.js';
+import { FileDiff } from '../tools/tools.js';
+import { AuthType } from '../core/contentGenerator.js';
+import {
+  getDecisionFromOutcome,
+  ToolCallDecision,
+} from './tool-call-decision.js';
+
+export interface BaseTelemetryEvent {
+  'event.name': string;
+  /** Current timestamp in ISO 8601 format */
+  'event.timestamp': string;
+}
+
+type CommonFields = keyof BaseTelemetryEvent;
+
+export class StartSessionEvent implements BaseTelemetryEvent {
+  'event.name': 'cli_config';
+  'event.timestamp': string;
+  model: string;
+  embedding_model: string;
+  sandbox_enabled: boolean;
+  core_tools_enabled: string;
+  approval_mode: string;
+  api_key_enabled: boolean;
+  vertex_ai_enabled: boolean;
+  debug_enabled: boolean;
+  mcp_servers: string;
+  telemetry_enabled: boolean;
+  telemetry_log_user_prompts_enabled: boolean;
+  file_filtering_respect_git_ignore: boolean;
+
+  constructor(config: Config) {
+    const generatorConfig = config.getContentGeneratorConfig();
+    const mcpServers = config.getMcpServers();
+
+    let useGemini = false;
+    let useVertex = false;
+    if (generatorConfig && generatorConfig.authType) {
+      useGemini = generatorConfig.authType === AuthType.USE_GEMINI;
+      useVertex = generatorConfig.authType === AuthType.USE_VERTEX_AI;
+    }
+
+    this['event.name'] = 'cli_config';
+    this.model = config.getModel();
+    this.embedding_model = config.getEmbeddingModel();
+    this.sandbox_enabled =
+      typeof config.getSandbox() === 'string' || !!config.getSandbox();
+    this.core_tools_enabled = (config.getCoreTools() ?? []).join(',');
+    this.approval_mode = config.getApprovalMode();
+    this.api_key_enabled = useGemini || useVertex;
+    this.vertex_ai_enabled = useVertex;
+    this.debug_enabled = config.getDebugMode();
+    this.mcp_servers = mcpServers ? Object.keys(mcpServers).join(',') : '';
+    this.telemetry_enabled = config.getTelemetryEnabled();
+    this.telemetry_log_user_prompts_enabled =
+      config.getTelemetryLogPromptsEnabled();
+    this.file_filtering_respect_git_ignore =
+      config.getFileFilteringRespectGitIgnore();
+  }
+}
+
+export class EndSessionEvent implements BaseTelemetryEvent {
+  'event.name': 'end_session';
+  'event.timestamp': string;
+  session_id?: string;
+
+  constructor(config?: Config) {
+    this['event.name'] = 'end_session';
+    this['event.timestamp'] = new Date().toISOString();
+    this.session_id = config?.getSessionId();
+  }
+}
+
+export class UserPromptEvent implements BaseTelemetryEvent {
+  'event.name': 'user_prompt';
+  'event.timestamp': string;
+  prompt_length: number;
+  prompt_id: string;
+  auth_type?: string;
+  prompt?: string;
+
+  constructor(
+    prompt_length: number,
+    prompt_Id: string,
+    auth_type?: string,
+    prompt?: string,
+  ) {
+    this['event.name'] = 'user_prompt';
+    this['event.timestamp'] = new Date().toISOString();
+    this.prompt_length = prompt_length;
+    this.prompt_id = prompt_Id;
+    this.auth_type = auth_type;
+    this.prompt = prompt;
+  }
+}
+
+export class ToolCallEvent implements BaseTelemetryEvent {
+  'event.name': 'tool_call';
+  'event.timestamp': string;
+  function_name: string;
+  function_args: Record<string, unknown>;
+  duration_ms: number;
+  success: boolean;
+  decision?: ToolCallDecision;
+  error?: string;
+  error_type?: string;
+  prompt_id: string;
+  tool_type: 'native' | 'mcp';
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  metadata?: { [key: string]: any };
+
+  constructor(call: CompletedToolCall) {
+    this['event.name'] = 'tool_call';
+    this['event.timestamp'] = new Date().toISOString();
+    this.function_name = call.request.name;
+    this.function_args = call.request.args;
+    this.duration_ms = call.durationMs ?? 0;
+    this.success = call.status === 'success';
+    this.decision = call.outcome
+      ? getDecisionFromOutcome(call.outcome)
+      : undefined;
+    this.error = call.response.error?.message;
+    this.error_type = call.response.errorType;
+    this.prompt_id = call.request.prompt_id;
+    this.tool_type =
+      typeof call.tool !== 'undefined' && call.tool instanceof DiscoveredMCPTool
+        ? 'mcp'
+        : 'native';
+
+    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,
+        };
+      }
+    }
+  }
+}
+
+export class ApiRequestEvent implements BaseTelemetryEvent {
+  'event.name': 'api_request';
+  'event.timestamp': string;
+  model: string;
+  prompt_id: string;
+  request_text?: string;
+
+  constructor(model: string, prompt_id: string, request_text?: string) {
+    this['event.name'] = 'api_request';
+    this['event.timestamp'] = new Date().toISOString();
+    this.model = model;
+    this.prompt_id = prompt_id;
+    this.request_text = request_text;
+  }
+}
+
+export class ApiErrorEvent implements BaseTelemetryEvent {
+  'event.name': 'api_error';
+  'event.timestamp': string; // ISO 8601
+  response_id?: string;
+  model: string;
+  error: string;
+  error_type?: string;
+  status_code?: number | string;
+  duration_ms: number;
+  prompt_id: string;
+  auth_type?: string;
+
+  constructor(
+    response_id: string | undefined,
+    model: string,
+    error: string,
+    duration_ms: number,
+    prompt_id: string,
+    auth_type?: string,
+    error_type?: string,
+    status_code?: number | string,
+  ) {
+    this['event.name'] = 'api_error';
+    this['event.timestamp'] = new Date().toISOString();
+    this.response_id = response_id;
+    this.model = model;
+    this.error = error;
+    this.error_type = error_type;
+    this.status_code = status_code;
+    this.duration_ms = duration_ms;
+    this.prompt_id = prompt_id;
+    this.auth_type = auth_type;
+  }
+}
+
+export class ApiResponseEvent implements BaseTelemetryEvent {
+  'event.name': 'api_response';
+  'event.timestamp': string; // ISO 8601
+  response_id: string;
+  model: string;
+  status_code?: number | string;
+  duration_ms: number;
+  error?: string;
+  input_token_count: number;
+  output_token_count: number;
+  cached_content_token_count: number;
+  thoughts_token_count: number;
+  tool_token_count: number;
+  total_token_count: number;
+  response_text?: string;
+  prompt_id: string;
+  auth_type?: string;
+
+  constructor(
+    response_id: string,
+    model: string,
+    duration_ms: number,
+    prompt_id: string,
+    auth_type?: string,
+    usage_data?: GenerateContentResponseUsageMetadata,
+    response_text?: string,
+    error?: string,
+  ) {
+    this['event.name'] = 'api_response';
+    this['event.timestamp'] = new Date().toISOString();
+    this.response_id = response_id;
+    this.model = model;
+    this.duration_ms = duration_ms;
+    this.status_code = 200;
+    this.input_token_count = usage_data?.promptTokenCount ?? 0;
+    this.output_token_count = usage_data?.candidatesTokenCount ?? 0;
+    this.cached_content_token_count = usage_data?.cachedContentTokenCount ?? 0;
+    this.thoughts_token_count = usage_data?.thoughtsTokenCount ?? 0;
+    this.tool_token_count = usage_data?.toolUsePromptTokenCount ?? 0;
+    this.total_token_count = usage_data?.totalTokenCount ?? 0;
+    this.response_text = response_text;
+    this.error = error;
+    this.prompt_id = prompt_id;
+    this.auth_type = auth_type;
+  }
+}
+
+export class FlashFallbackEvent implements BaseTelemetryEvent {
+  'event.name': 'flash_fallback';
+  'event.timestamp': string;
+  auth_type: string;
+
+  constructor(auth_type: string) {
+    this['event.name'] = 'flash_fallback';
+    this['event.timestamp'] = new Date().toISOString();
+    this.auth_type = auth_type;
+  }
+}
+
+export enum LoopType {
+  CONSECUTIVE_IDENTICAL_TOOL_CALLS = 'consecutive_identical_tool_calls',
+  CHANTING_IDENTICAL_SENTENCES = 'chanting_identical_sentences',
+  LLM_DETECTED_LOOP = 'llm_detected_loop',
+}
+
+export class LoopDetectedEvent implements BaseTelemetryEvent {
+  'event.name': 'loop_detected';
+  'event.timestamp': string;
+  loop_type: LoopType;
+  prompt_id: string;
+
+  constructor(loop_type: LoopType, prompt_id: string) {
+    this['event.name'] = 'loop_detected';
+    this['event.timestamp'] = new Date().toISOString();
+    this.loop_type = loop_type;
+    this.prompt_id = prompt_id;
+  }
+}
+
+export class NextSpeakerCheckEvent implements BaseTelemetryEvent {
+  'event.name': 'next_speaker_check';
+  'event.timestamp': string;
+  prompt_id: string;
+  finish_reason: string;
+  result: string;
+
+  constructor(prompt_id: string, finish_reason: string, result: string) {
+    this['event.name'] = 'next_speaker_check';
+    this['event.timestamp'] = new Date().toISOString();
+    this.prompt_id = prompt_id;
+    this.finish_reason = finish_reason;
+    this.result = result;
+  }
+}
+
+export interface SlashCommandEvent extends BaseTelemetryEvent {
+  'event.name': 'slash_command';
+  'event.timestamp': string;
+  command: string;
+  subcommand?: string;
+  status?: SlashCommandStatus;
+}
+
+export function makeSlashCommandEvent({
+  command,
+  subcommand,
+  status,
+}: Omit<SlashCommandEvent, CommonFields>): SlashCommandEvent {
+  return {
+    'event.name': 'slash_command',
+    'event.timestamp': new Date().toISOString(),
+    command,
+    subcommand,
+    status,
+  };
+}
+
+export enum SlashCommandStatus {
+  SUCCESS = 'success',
+  ERROR = 'error',
+}
+
+export interface ChatCompressionEvent extends BaseTelemetryEvent {
+  'event.name': 'chat_compression';
+  'event.timestamp': string;
+  tokens_before: number;
+  tokens_after: number;
+}
+
+export function makeChatCompressionEvent({
+  tokens_before,
+  tokens_after,
+}: Omit<ChatCompressionEvent, CommonFields>): ChatCompressionEvent {
+  return {
+    'event.name': 'chat_compression',
+    'event.timestamp': new Date().toISOString(),
+    tokens_before,
+    tokens_after,
+  };
+}
+
+export class MalformedJsonResponseEvent implements BaseTelemetryEvent {
+  'event.name': 'malformed_json_response';
+  'event.timestamp': string;
+  model: string;
+
+  constructor(model: string) {
+    this['event.name'] = 'malformed_json_response';
+    this['event.timestamp'] = new Date().toISOString();
+    this.model = model;
+  }
+}
+
+export enum IdeConnectionType {
+  START = 'start',
+  SESSION = 'session',
+}
+
+export class IdeConnectionEvent {
+  'event.name': 'ide_connection';
+  'event.timestamp': string;
+  connection_type: IdeConnectionType;
+
+  constructor(connection_type: IdeConnectionType) {
+    this['event.name'] = 'ide_connection';
+    this['event.timestamp'] = new Date().toISOString();
+    this.connection_type = connection_type;
+  }
+}
+
+export class KittySequenceOverflowEvent {
+  'event.name': 'kitty_sequence_overflow';
+  'event.timestamp': string; // ISO 8601
+  sequence_length: number;
+  truncated_sequence: string;
+  constructor(sequence_length: number, truncated_sequence: string) {
+    this['event.name'] = 'kitty_sequence_overflow';
+    this['event.timestamp'] = new Date().toISOString();
+    this.sequence_length = sequence_length;
+    // Truncate to first 20 chars for logging (avoid logging sensitive data)
+    this.truncated_sequence = truncated_sequence.substring(0, 20);
+  }
+}
+
+// Add these new event interfaces
+export class InvalidChunkEvent implements BaseTelemetryEvent {
+  'event.name': 'invalid_chunk';
+  'event.timestamp': string;
+  error_message?: string; // Optional: validation error details
+
+  constructor(error_message?: string) {
+    this['event.name'] = 'invalid_chunk';
+    this['event.timestamp'] = new Date().toISOString();
+    this.error_message = error_message;
+  }
+}
+
+export class ContentRetryEvent implements BaseTelemetryEvent {
+  'event.name': 'content_retry';
+  'event.timestamp': string;
+  attempt_number: number;
+  error_type: string; // e.g., 'EmptyStreamError'
+  retry_delay_ms: number;
+
+  constructor(
+    attempt_number: number,
+    error_type: string,
+    retry_delay_ms: number,
+  ) {
+    this['event.name'] = 'content_retry';
+    this['event.timestamp'] = new Date().toISOString();
+    this.attempt_number = attempt_number;
+    this.error_type = error_type;
+    this.retry_delay_ms = retry_delay_ms;
+  }
+}
+
+export class ContentRetryFailureEvent implements BaseTelemetryEvent {
+  'event.name': 'content_retry_failure';
+  'event.timestamp': string;
+  total_attempts: number;
+  final_error_type: string;
+  total_duration_ms?: number; // Optional: total time spent retrying
+
+  constructor(
+    total_attempts: number,
+    final_error_type: string,
+    total_duration_ms?: number,
+  ) {
+    this['event.name'] = 'content_retry_failure';
+    this['event.timestamp'] = new Date().toISOString();
+    this.total_attempts = total_attempts;
+    this.final_error_type = final_error_type;
+    this.total_duration_ms = total_duration_ms;
+  }
+}
+
+export type TelemetryEvent =
+  | StartSessionEvent
+  | EndSessionEvent
+  | UserPromptEvent
+  | ToolCallEvent
+  | ApiRequestEvent
+  | ApiErrorEvent
+  | ApiResponseEvent
+  | FlashFallbackEvent
+  | LoopDetectedEvent
+  | NextSpeakerCheckEvent
+  | KittySequenceOverflowEvent
+  | MalformedJsonResponseEvent
+  | IdeConnectionEvent
+  | SlashCommandEvent
+  | InvalidChunkEvent
+  | ContentRetryEvent
+  | ContentRetryFailureEvent;

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

@@ -0,0 +1,674 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { UiTelemetryService } from './uiTelemetry.js';
+import { ToolCallDecision } from './tool-call-decision.js';
+import { ApiErrorEvent, ApiResponseEvent, ToolCallEvent } from './types.js';
+import {
+  EVENT_API_ERROR,
+  EVENT_API_RESPONSE,
+  EVENT_TOOL_CALL,
+} from './constants.js';
+import {
+  CompletedToolCall,
+  ErroredToolCall,
+  SuccessfulToolCall,
+} from '../core/coreToolScheduler.js';
+import { ToolErrorType } from '../tools/tool-error.js';
+import { ToolConfirmationOutcome } from '../tools/tools.js';
+import { MockTool } from '../test-utils/tools.js';
+
+const createFakeCompletedToolCall = (
+  name: string,
+  success: boolean,
+  duration = 100,
+  outcome?: ToolConfirmationOutcome,
+  error?: Error,
+): CompletedToolCall => {
+  const request = {
+    callId: `call_${name}_${Date.now()}`,
+    name,
+    args: { foo: 'bar' },
+    isClientInitiated: false,
+    prompt_id: 'prompt-id-1',
+  };
+  const tool = new MockTool(name);
+
+  if (success) {
+    return {
+      status: 'success',
+      request,
+      tool,
+      invocation: tool.build({ param: 'test' }),
+      response: {
+        callId: request.callId,
+        responseParts: {
+          functionResponse: {
+            id: request.callId,
+            name,
+            response: { output: 'Success!' },
+          },
+        },
+        error: undefined,
+        errorType: undefined,
+        resultDisplay: 'Success!',
+      },
+      durationMs: duration,
+      outcome,
+    } as SuccessfulToolCall;
+  } else {
+    return {
+      status: 'error',
+      request,
+      tool,
+      response: {
+        callId: request.callId,
+        responseParts: {
+          functionResponse: {
+            id: request.callId,
+            name,
+            response: { error: 'Tool failed' },
+          },
+        },
+        error: error || new Error('Tool failed'),
+        errorType: ToolErrorType.UNKNOWN,
+        resultDisplay: 'Failure!',
+      },
+      durationMs: duration,
+      outcome,
+    } as ErroredToolCall;
+  }
+};
+
+describe('UiTelemetryService', () => {
+  let service: UiTelemetryService;
+
+  beforeEach(() => {
+    service = new UiTelemetryService();
+  });
+
+  it('should have correct initial metrics', () => {
+    const metrics = service.getMetrics();
+    expect(metrics).toEqual({
+      models: {},
+      tools: {
+        totalCalls: 0,
+        totalSuccess: 0,
+        totalFail: 0,
+        totalDurationMs: 0,
+        totalDecisions: {
+          [ToolCallDecision.ACCEPT]: 0,
+          [ToolCallDecision.REJECT]: 0,
+          [ToolCallDecision.MODIFY]: 0,
+          [ToolCallDecision.AUTO_ACCEPT]: 0,
+        },
+        byName: {},
+      },
+      files: {
+        totalLinesAdded: 0,
+        totalLinesRemoved: 0,
+      },
+    });
+    expect(service.getLastPromptTokenCount()).toBe(0);
+  });
+
+  it('should emit an update event when an event is added', () => {
+    const spy = vi.fn();
+    service.on('update', spy);
+
+    const event = {
+      'event.name': EVENT_API_RESPONSE,
+      model: 'gemini-2.5-pro',
+      duration_ms: 500,
+      input_token_count: 10,
+      output_token_count: 20,
+      total_token_count: 30,
+      cached_content_token_count: 5,
+      thoughts_token_count: 2,
+      tool_token_count: 3,
+    } as ApiResponseEvent & { 'event.name': typeof EVENT_API_RESPONSE };
+
+    service.addEvent(event);
+
+    expect(spy).toHaveBeenCalledOnce();
+    const { metrics, lastPromptTokenCount } = spy.mock.calls[0][0];
+    expect(metrics).toBeDefined();
+    expect(lastPromptTokenCount).toBe(10);
+  });
+
+  describe('API Response Event Processing', () => {
+    it('should process a single ApiResponseEvent', () => {
+      const event = {
+        'event.name': EVENT_API_RESPONSE,
+        model: 'gemini-2.5-pro',
+        duration_ms: 500,
+        input_token_count: 10,
+        output_token_count: 20,
+        total_token_count: 30,
+        cached_content_token_count: 5,
+        thoughts_token_count: 2,
+        tool_token_count: 3,
+      } as ApiResponseEvent & { 'event.name': typeof EVENT_API_RESPONSE };
+
+      service.addEvent(event);
+
+      const metrics = service.getMetrics();
+      expect(metrics.models['gemini-2.5-pro']).toEqual({
+        api: {
+          totalRequests: 1,
+          totalErrors: 0,
+          totalLatencyMs: 500,
+        },
+        tokens: {
+          prompt: 10,
+          candidates: 20,
+          total: 30,
+          cached: 5,
+          thoughts: 2,
+          tool: 3,
+        },
+      });
+      expect(service.getLastPromptTokenCount()).toBe(10);
+    });
+
+    it('should aggregate multiple ApiResponseEvents for the same model', () => {
+      const event1 = {
+        'event.name': EVENT_API_RESPONSE,
+        model: 'gemini-2.5-pro',
+        duration_ms: 500,
+        input_token_count: 10,
+        output_token_count: 20,
+        total_token_count: 30,
+        cached_content_token_count: 5,
+        thoughts_token_count: 2,
+        tool_token_count: 3,
+      } as ApiResponseEvent & {
+        'event.name': typeof EVENT_API_RESPONSE;
+      };
+      const event2 = {
+        'event.name': EVENT_API_RESPONSE,
+        model: 'gemini-2.5-pro',
+        duration_ms: 600,
+        input_token_count: 15,
+        output_token_count: 25,
+        total_token_count: 40,
+        cached_content_token_count: 10,
+        thoughts_token_count: 4,
+        tool_token_count: 6,
+      } as ApiResponseEvent & {
+        'event.name': typeof EVENT_API_RESPONSE;
+      };
+
+      service.addEvent(event1);
+      service.addEvent(event2);
+
+      const metrics = service.getMetrics();
+      expect(metrics.models['gemini-2.5-pro']).toEqual({
+        api: {
+          totalRequests: 2,
+          totalErrors: 0,
+          totalLatencyMs: 1100,
+        },
+        tokens: {
+          prompt: 25,
+          candidates: 45,
+          total: 70,
+          cached: 15,
+          thoughts: 6,
+          tool: 9,
+        },
+      });
+      expect(service.getLastPromptTokenCount()).toBe(15);
+    });
+
+    it('should handle ApiResponseEvents for different models', () => {
+      const event1 = {
+        'event.name': EVENT_API_RESPONSE,
+        model: 'gemini-2.5-pro',
+        duration_ms: 500,
+        input_token_count: 10,
+        output_token_count: 20,
+        total_token_count: 30,
+        cached_content_token_count: 5,
+        thoughts_token_count: 2,
+        tool_token_count: 3,
+      } as ApiResponseEvent & {
+        'event.name': typeof EVENT_API_RESPONSE;
+      };
+      const event2 = {
+        'event.name': EVENT_API_RESPONSE,
+        model: 'gemini-2.5-flash',
+        duration_ms: 1000,
+        input_token_count: 100,
+        output_token_count: 200,
+        total_token_count: 300,
+        cached_content_token_count: 50,
+        thoughts_token_count: 20,
+        tool_token_count: 30,
+      } as ApiResponseEvent & {
+        'event.name': typeof EVENT_API_RESPONSE;
+      };
+
+      service.addEvent(event1);
+      service.addEvent(event2);
+
+      const metrics = service.getMetrics();
+      expect(metrics.models['gemini-2.5-pro']).toBeDefined();
+      expect(metrics.models['gemini-2.5-flash']).toBeDefined();
+      expect(metrics.models['gemini-2.5-pro'].api.totalRequests).toBe(1);
+      expect(metrics.models['gemini-2.5-flash'].api.totalRequests).toBe(1);
+      expect(service.getLastPromptTokenCount()).toBe(100);
+    });
+  });
+
+  describe('API Error Event Processing', () => {
+    it('should process a single ApiErrorEvent', () => {
+      const event = {
+        'event.name': EVENT_API_ERROR,
+        model: 'gemini-2.5-pro',
+        duration_ms: 300,
+        error: 'Something went wrong',
+      } as ApiErrorEvent & { 'event.name': typeof EVENT_API_ERROR };
+
+      service.addEvent(event);
+
+      const metrics = service.getMetrics();
+      expect(metrics.models['gemini-2.5-pro']).toEqual({
+        api: {
+          totalRequests: 1,
+          totalErrors: 1,
+          totalLatencyMs: 300,
+        },
+        tokens: {
+          prompt: 0,
+          candidates: 0,
+          total: 0,
+          cached: 0,
+          thoughts: 0,
+          tool: 0,
+        },
+      });
+    });
+
+    it('should aggregate ApiErrorEvents and ApiResponseEvents', () => {
+      const responseEvent = {
+        'event.name': EVENT_API_RESPONSE,
+        model: 'gemini-2.5-pro',
+        duration_ms: 500,
+        input_token_count: 10,
+        output_token_count: 20,
+        total_token_count: 30,
+        cached_content_token_count: 5,
+        thoughts_token_count: 2,
+        tool_token_count: 3,
+      } as ApiResponseEvent & {
+        'event.name': typeof EVENT_API_RESPONSE;
+      };
+      const errorEvent = {
+        'event.name': EVENT_API_ERROR,
+        model: 'gemini-2.5-pro',
+        duration_ms: 300,
+        error: 'Something went wrong',
+      } as ApiErrorEvent & { 'event.name': typeof EVENT_API_ERROR };
+
+      service.addEvent(responseEvent);
+      service.addEvent(errorEvent);
+
+      const metrics = service.getMetrics();
+      expect(metrics.models['gemini-2.5-pro']).toEqual({
+        api: {
+          totalRequests: 2,
+          totalErrors: 1,
+          totalLatencyMs: 800,
+        },
+        tokens: {
+          prompt: 10,
+          candidates: 20,
+          total: 30,
+          cached: 5,
+          thoughts: 2,
+          tool: 3,
+        },
+      });
+    });
+  });
+
+  describe('Tool Call Event Processing', () => {
+    it('should process a single successful ToolCallEvent', () => {
+      const toolCall = createFakeCompletedToolCall(
+        'test_tool',
+        true,
+        150,
+        ToolConfirmationOutcome.ProceedOnce,
+      );
+      service.addEvent({
+        ...structuredClone(new ToolCallEvent(toolCall)),
+        'event.name': EVENT_TOOL_CALL,
+      } as ToolCallEvent & { 'event.name': typeof EVENT_TOOL_CALL });
+
+      const metrics = service.getMetrics();
+      const { tools } = metrics;
+
+      expect(tools.totalCalls).toBe(1);
+      expect(tools.totalSuccess).toBe(1);
+      expect(tools.totalFail).toBe(0);
+      expect(tools.totalDurationMs).toBe(150);
+      expect(tools.totalDecisions[ToolCallDecision.ACCEPT]).toBe(1);
+      expect(tools.byName['test_tool']).toEqual({
+        count: 1,
+        success: 1,
+        fail: 0,
+        durationMs: 150,
+        decisions: {
+          [ToolCallDecision.ACCEPT]: 1,
+          [ToolCallDecision.REJECT]: 0,
+          [ToolCallDecision.MODIFY]: 0,
+          [ToolCallDecision.AUTO_ACCEPT]: 0,
+        },
+      });
+    });
+
+    it('should process a single failed ToolCallEvent', () => {
+      const toolCall = createFakeCompletedToolCall(
+        'test_tool',
+        false,
+        200,
+        ToolConfirmationOutcome.Cancel,
+      );
+      service.addEvent({
+        ...structuredClone(new ToolCallEvent(toolCall)),
+        'event.name': EVENT_TOOL_CALL,
+      } as ToolCallEvent & { 'event.name': typeof EVENT_TOOL_CALL });
+
+      const metrics = service.getMetrics();
+      const { tools } = metrics;
+
+      expect(tools.totalCalls).toBe(1);
+      expect(tools.totalSuccess).toBe(0);
+      expect(tools.totalFail).toBe(1);
+      expect(tools.totalDurationMs).toBe(200);
+      expect(tools.totalDecisions[ToolCallDecision.REJECT]).toBe(1);
+      expect(tools.byName['test_tool']).toEqual({
+        count: 1,
+        success: 0,
+        fail: 1,
+        durationMs: 200,
+        decisions: {
+          [ToolCallDecision.ACCEPT]: 0,
+          [ToolCallDecision.REJECT]: 1,
+          [ToolCallDecision.MODIFY]: 0,
+          [ToolCallDecision.AUTO_ACCEPT]: 0,
+        },
+      });
+    });
+
+    it('should process a ToolCallEvent with modify decision', () => {
+      const toolCall = createFakeCompletedToolCall(
+        'test_tool',
+        true,
+        250,
+        ToolConfirmationOutcome.ModifyWithEditor,
+      );
+      service.addEvent({
+        ...structuredClone(new ToolCallEvent(toolCall)),
+        'event.name': EVENT_TOOL_CALL,
+      } as ToolCallEvent & { 'event.name': typeof EVENT_TOOL_CALL });
+
+      const metrics = service.getMetrics();
+      const { tools } = metrics;
+
+      expect(tools.totalDecisions[ToolCallDecision.MODIFY]).toBe(1);
+      expect(tools.byName['test_tool'].decisions[ToolCallDecision.MODIFY]).toBe(
+        1,
+      );
+    });
+
+    it('should process a ToolCallEvent without a decision', () => {
+      const toolCall = createFakeCompletedToolCall('test_tool', true, 100);
+      service.addEvent({
+        ...structuredClone(new ToolCallEvent(toolCall)),
+        'event.name': EVENT_TOOL_CALL,
+      } as ToolCallEvent & { 'event.name': typeof EVENT_TOOL_CALL });
+
+      const metrics = service.getMetrics();
+      const { tools } = metrics;
+
+      expect(tools.totalDecisions).toEqual({
+        [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,
+      });
+    });
+
+    it('should aggregate multiple ToolCallEvents for the same tool', () => {
+      const toolCall1 = createFakeCompletedToolCall(
+        'test_tool',
+        true,
+        100,
+        ToolConfirmationOutcome.ProceedOnce,
+      );
+      const toolCall2 = createFakeCompletedToolCall(
+        'test_tool',
+        false,
+        150,
+        ToolConfirmationOutcome.Cancel,
+      );
+
+      service.addEvent({
+        ...structuredClone(new ToolCallEvent(toolCall1)),
+        'event.name': EVENT_TOOL_CALL,
+      } as ToolCallEvent & { 'event.name': typeof EVENT_TOOL_CALL });
+      service.addEvent({
+        ...structuredClone(new ToolCallEvent(toolCall2)),
+        'event.name': EVENT_TOOL_CALL,
+      } as ToolCallEvent & { 'event.name': typeof EVENT_TOOL_CALL });
+
+      const metrics = service.getMetrics();
+      const { tools } = metrics;
+
+      expect(tools.totalCalls).toBe(2);
+      expect(tools.totalSuccess).toBe(1);
+      expect(tools.totalFail).toBe(1);
+      expect(tools.totalDurationMs).toBe(250);
+      expect(tools.totalDecisions[ToolCallDecision.ACCEPT]).toBe(1);
+      expect(tools.totalDecisions[ToolCallDecision.REJECT]).toBe(1);
+      expect(tools.byName['test_tool']).toEqual({
+        count: 2,
+        success: 1,
+        fail: 1,
+        durationMs: 250,
+        decisions: {
+          [ToolCallDecision.ACCEPT]: 1,
+          [ToolCallDecision.REJECT]: 1,
+          [ToolCallDecision.MODIFY]: 0,
+          [ToolCallDecision.AUTO_ACCEPT]: 0,
+        },
+      });
+    });
+
+    it('should handle ToolCallEvents for different tools', () => {
+      const toolCall1 = createFakeCompletedToolCall('tool_A', true, 100);
+      const toolCall2 = createFakeCompletedToolCall('tool_B', false, 200);
+      service.addEvent({
+        ...structuredClone(new ToolCallEvent(toolCall1)),
+        'event.name': EVENT_TOOL_CALL,
+      } as ToolCallEvent & { 'event.name': typeof EVENT_TOOL_CALL });
+      service.addEvent({
+        ...structuredClone(new ToolCallEvent(toolCall2)),
+        'event.name': EVENT_TOOL_CALL,
+      } as ToolCallEvent & { 'event.name': typeof EVENT_TOOL_CALL });
+
+      const metrics = service.getMetrics();
+      const { tools } = metrics;
+
+      expect(tools.totalCalls).toBe(2);
+      expect(tools.totalSuccess).toBe(1);
+      expect(tools.totalFail).toBe(1);
+      expect(tools.byName['tool_A']).toBeDefined();
+      expect(tools.byName['tool_B']).toBeDefined();
+      expect(tools.byName['tool_A'].count).toBe(1);
+      expect(tools.byName['tool_B'].count).toBe(1);
+    });
+  });
+
+  describe('resetLastPromptTokenCount', () => {
+    it('should reset the last prompt token count to 0', () => {
+      // First, set up some initial token count
+      const event = {
+        'event.name': EVENT_API_RESPONSE,
+        model: 'gemini-2.5-pro',
+        duration_ms: 500,
+        input_token_count: 100,
+        output_token_count: 200,
+        total_token_count: 300,
+        cached_content_token_count: 50,
+        thoughts_token_count: 20,
+        tool_token_count: 30,
+      } as ApiResponseEvent & { 'event.name': typeof EVENT_API_RESPONSE };
+
+      service.addEvent(event);
+      expect(service.getLastPromptTokenCount()).toBe(100);
+
+      // Now reset the token count
+      service.resetLastPromptTokenCount();
+      expect(service.getLastPromptTokenCount()).toBe(0);
+    });
+
+    it('should emit an update event when resetLastPromptTokenCount is called', () => {
+      const spy = vi.fn();
+      service.on('update', spy);
+
+      // Set up initial token count
+      const event = {
+        'event.name': EVENT_API_RESPONSE,
+        model: 'gemini-2.5-pro',
+        duration_ms: 500,
+        input_token_count: 100,
+        output_token_count: 200,
+        total_token_count: 300,
+        cached_content_token_count: 50,
+        thoughts_token_count: 20,
+        tool_token_count: 30,
+      } as ApiResponseEvent & { 'event.name': typeof EVENT_API_RESPONSE };
+
+      service.addEvent(event);
+      spy.mockClear(); // Clear the spy to focus on the reset call
+
+      service.resetLastPromptTokenCount();
+
+      expect(spy).toHaveBeenCalledOnce();
+      const { metrics, lastPromptTokenCount } = spy.mock.calls[0][0];
+      expect(metrics).toBeDefined();
+      expect(lastPromptTokenCount).toBe(0);
+    });
+
+    it('should not affect other metrics when resetLastPromptTokenCount is called', () => {
+      // Set up initial state with some metrics
+      const event = {
+        'event.name': EVENT_API_RESPONSE,
+        model: 'gemini-2.5-pro',
+        duration_ms: 500,
+        input_token_count: 100,
+        output_token_count: 200,
+        total_token_count: 300,
+        cached_content_token_count: 50,
+        thoughts_token_count: 20,
+        tool_token_count: 30,
+      } as ApiResponseEvent & { 'event.name': typeof EVENT_API_RESPONSE };
+
+      service.addEvent(event);
+
+      const metricsBefore = service.getMetrics();
+
+      service.resetLastPromptTokenCount();
+
+      const metricsAfter = service.getMetrics();
+
+      // Metrics should be unchanged
+      expect(metricsAfter).toEqual(metricsBefore);
+
+      // Only the last prompt token count should be reset
+      expect(service.getLastPromptTokenCount()).toBe(0);
+    });
+
+    it('should work correctly when called multiple times', () => {
+      const spy = vi.fn();
+      service.on('update', spy);
+
+      // Set up initial token count
+      const event = {
+        'event.name': EVENT_API_RESPONSE,
+        model: 'gemini-2.5-pro',
+        duration_ms: 500,
+        input_token_count: 100,
+        output_token_count: 200,
+        total_token_count: 300,
+        cached_content_token_count: 50,
+        thoughts_token_count: 20,
+        tool_token_count: 30,
+      } as ApiResponseEvent & { 'event.name': typeof EVENT_API_RESPONSE };
+
+      service.addEvent(event);
+      expect(service.getLastPromptTokenCount()).toBe(100);
+
+      // Reset once
+      service.resetLastPromptTokenCount();
+      expect(service.getLastPromptTokenCount()).toBe(0);
+
+      // Reset again - should still be 0 and still emit event
+      spy.mockClear();
+      service.resetLastPromptTokenCount();
+      expect(service.getLastPromptTokenCount()).toBe(0);
+      expect(spy).toHaveBeenCalledOnce();
+    });
+  });
+
+  describe('Tool Call Event with Line Count Metadata', () => {
+    it('should aggregate valid line count metadata', () => {
+      const toolCall = createFakeCompletedToolCall('test_tool', true, 100);
+      const event = {
+        ...structuredClone(new ToolCallEvent(toolCall)),
+        'event.name': EVENT_TOOL_CALL,
+        metadata: {
+          ai_added_lines: 10,
+          ai_removed_lines: 5,
+        },
+      } as ToolCallEvent & { 'event.name': typeof EVENT_TOOL_CALL };
+
+      service.addEvent(event);
+
+      const metrics = service.getMetrics();
+      expect(metrics.files.totalLinesAdded).toBe(10);
+      expect(metrics.files.totalLinesRemoved).toBe(5);
+    });
+
+    it('should ignore null/undefined values in line count metadata', () => {
+      const toolCall = createFakeCompletedToolCall('test_tool', true, 100);
+      const event = {
+        ...structuredClone(new ToolCallEvent(toolCall)),
+        'event.name': EVENT_TOOL_CALL,
+        metadata: {
+          ai_added_lines: null,
+          ai_removed_lines: undefined,
+        },
+      } as ToolCallEvent & { 'event.name': typeof EVENT_TOOL_CALL };
+
+      service.addEvent(event);
+
+      const metrics = service.getMetrics();
+      expect(metrics.files.totalLinesAdded).toBe(0);
+      expect(metrics.files.totalLinesRemoved).toBe(0);
+    });
+  });
+});

projects/ui/qwen-code/packages/core/src/telemetry/uiTelemetry.ts

@@ -0,0 +1,233 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { EventEmitter } from 'events';
+import {
+  EVENT_API_ERROR,
+  EVENT_API_RESPONSE,
+  EVENT_TOOL_CALL,
+} from './constants.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 })
+  | (ApiErrorEvent & { 'event.name': typeof EVENT_API_ERROR })
+  | (ToolCallEvent & { 'event.name': typeof EVENT_TOOL_CALL });
+
+export interface ToolCallStats {
+  count: number;
+  success: number;
+  fail: number;
+  durationMs: number;
+  decisions: {
+    [ToolCallDecision.ACCEPT]: number;
+    [ToolCallDecision.REJECT]: number;
+    [ToolCallDecision.MODIFY]: number;
+    [ToolCallDecision.AUTO_ACCEPT]: number;
+  };
+}
+
+export interface ModelMetrics {
+  api: {
+    totalRequests: number;
+    totalErrors: number;
+    totalLatencyMs: number;
+  };
+  tokens: {
+    prompt: number;
+    candidates: number;
+    total: number;
+    cached: number;
+    thoughts: number;
+    tool: number;
+  };
+}
+
+export interface SessionMetrics {
+  models: Record<string, ModelMetrics>;
+  tools: {
+    totalCalls: number;
+    totalSuccess: number;
+    totalFail: number;
+    totalDurationMs: number;
+    totalDecisions: {
+      [ToolCallDecision.ACCEPT]: number;
+      [ToolCallDecision.REJECT]: number;
+      [ToolCallDecision.MODIFY]: number;
+      [ToolCallDecision.AUTO_ACCEPT]: number;
+    };
+    byName: Record<string, ToolCallStats>;
+  };
+  files: {
+    totalLinesAdded: number;
+    totalLinesRemoved: number;
+  };
+}
+
+const createInitialModelMetrics = (): ModelMetrics => ({
+  api: {
+    totalRequests: 0,
+    totalErrors: 0,
+    totalLatencyMs: 0,
+  },
+  tokens: {
+    prompt: 0,
+    candidates: 0,
+    total: 0,
+    cached: 0,
+    thoughts: 0,
+    tool: 0,
+  },
+});
+
+const createInitialMetrics = (): SessionMetrics => ({
+  models: {},
+  tools: {
+    totalCalls: 0,
+    totalSuccess: 0,
+    totalFail: 0,
+    totalDurationMs: 0,
+    totalDecisions: {
+      [ToolCallDecision.ACCEPT]: 0,
+      [ToolCallDecision.REJECT]: 0,
+      [ToolCallDecision.MODIFY]: 0,
+      [ToolCallDecision.AUTO_ACCEPT]: 0,
+    },
+    byName: {},
+  },
+  files: {
+    totalLinesAdded: 0,
+    totalLinesRemoved: 0,
+  },
+});
+
+export class UiTelemetryService extends EventEmitter {
+  #metrics: SessionMetrics = createInitialMetrics();
+  #lastPromptTokenCount = 0;
+
+  addEvent(event: UiEvent) {
+    switch (event['event.name']) {
+      case EVENT_API_RESPONSE:
+        this.processApiResponse(event);
+        break;
+      case EVENT_API_ERROR:
+        this.processApiError(event);
+        break;
+      case EVENT_TOOL_CALL:
+        this.processToolCall(event);
+        break;
+      default:
+        // We should not emit update for any other event metric.
+        return;
+    }
+
+    this.emit('update', {
+      metrics: this.#metrics,
+      lastPromptTokenCount: this.#lastPromptTokenCount,
+    });
+  }
+
+  getMetrics(): SessionMetrics {
+    return this.#metrics;
+  }
+
+  getLastPromptTokenCount(): number {
+    return this.#lastPromptTokenCount;
+  }
+
+  resetLastPromptTokenCount(): void {
+    this.#lastPromptTokenCount = 0;
+    this.emit('update', {
+      metrics: this.#metrics,
+      lastPromptTokenCount: this.#lastPromptTokenCount,
+    });
+  }
+
+  private getOrCreateModelMetrics(modelName: string): ModelMetrics {
+    if (!this.#metrics.models[modelName]) {
+      this.#metrics.models[modelName] = createInitialModelMetrics();
+    }
+    return this.#metrics.models[modelName];
+  }
+
+  private processApiResponse(event: ApiResponseEvent) {
+    const modelMetrics = this.getOrCreateModelMetrics(event.model);
+
+    modelMetrics.api.totalRequests++;
+    modelMetrics.api.totalLatencyMs += event.duration_ms;
+
+    modelMetrics.tokens.prompt += event.input_token_count;
+    modelMetrics.tokens.candidates += event.output_token_count;
+    modelMetrics.tokens.total += event.total_token_count;
+    modelMetrics.tokens.cached += event.cached_content_token_count;
+    modelMetrics.tokens.thoughts += event.thoughts_token_count;
+    modelMetrics.tokens.tool += event.tool_token_count;
+
+    this.#lastPromptTokenCount = event.input_token_count;
+  }
+
+  private processApiError(event: ApiErrorEvent) {
+    const modelMetrics = this.getOrCreateModelMetrics(event.model);
+    modelMetrics.api.totalRequests++;
+    modelMetrics.api.totalErrors++;
+    modelMetrics.api.totalLatencyMs += event.duration_ms;
+  }
+
+  private processToolCall(event: ToolCallEvent) {
+    const { tools, files } = this.#metrics;
+    tools.totalCalls++;
+    tools.totalDurationMs += event.duration_ms;
+
+    if (event.success) {
+      tools.totalSuccess++;
+    } else {
+      tools.totalFail++;
+    }
+
+    if (!tools.byName[event.function_name]) {
+      tools.byName[event.function_name] = {
+        count: 0,
+        success: 0,
+        fail: 0,
+        durationMs: 0,
+        decisions: {
+          [ToolCallDecision.ACCEPT]: 0,
+          [ToolCallDecision.REJECT]: 0,
+          [ToolCallDecision.MODIFY]: 0,
+          [ToolCallDecision.AUTO_ACCEPT]: 0,
+        },
+      };
+    }
+
+    const toolStats = tools.byName[event.function_name];
+    toolStats.count++;
+    toolStats.durationMs += event.duration_ms;
+    if (event.success) {
+      toolStats.success++;
+    } else {
+      toolStats.fail++;
+    }
+
+    if (event.decision) {
+      tools.totalDecisions[event.decision]++;
+      toolStats.decisions[event.decision]++;
+    }
+
+    // Aggregate line count data from metadata
+    if (event.metadata) {
+      if (event.metadata['ai_added_lines'] !== undefined) {
+        files.totalLinesAdded += event.metadata['ai_added_lines'];
+      }
+      if (event.metadata['ai_removed_lines'] !== undefined) {
+        files.totalLinesRemoved += event.metadata['ai_removed_lines'];
+      }
+    }
+  }
+}
+
+export const uiTelemetryService = new UiTelemetryService();

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

@@ -0,0 +1,36 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { Config, ConfigParameters } from '../config/config.js';
+
+/**
+ * Default parameters used for {@link FAKE_CONFIG}
+ */
+export const DEFAULT_CONFIG_PARAMETERS: ConfigParameters = {
+  usageStatisticsEnabled: true,
+  debugMode: false,
+  sessionId: 'test-session-id',
+  proxy: undefined,
+  model: 'gemini-9001-super-duper',
+  targetDir: '/',
+  cwd: '/',
+};
+
+/**
+ * Produces a config.  Default paramters are set to
+ * {@link DEFAULT_CONFIG_PARAMETERS}, optionally, fields can be specified to
+ * override those defaults.
+ */
+export function makeFakeConfig(
+  config: Partial<ConfigParameters> = {
+    ...DEFAULT_CONFIG_PARAMETERS,
+  },
+): Config {
+  return new Config({
+    ...DEFAULT_CONFIG_PARAMETERS,
+    ...config,
+  });
+}

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

@@ -0,0 +1,33 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { vi } from 'vitest';
+import { WorkspaceContext } from '../utils/workspaceContext.js';
+
+/**
+ * Creates a mock WorkspaceContext for testing
+ * @param rootDir The root directory to use for the mock
+ * @param additionalDirs Optional additional directories to include in the workspace
+ * @returns A mock WorkspaceContext instance
+ */
+export function createMockWorkspaceContext(
+  rootDir: string,
+  additionalDirs: string[] = [],
+): WorkspaceContext {
+  const allDirs = [rootDir, ...additionalDirs];
+
+  const mockWorkspaceContext = {
+    addDirectory: vi.fn(),
+    getDirectories: vi.fn().mockReturnValue(allDirs),
+    isPathWithinWorkspace: vi
+      .fn()
+      .mockImplementation((path: string) =>
+        allDirs.some((dir) => path.startsWith(dir)),
+      ),
+  } as unknown as WorkspaceContext;
+
+  return mockWorkspaceContext;
+}

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

@@ -0,0 +1,167 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { vi } from 'vitest';
+import {
+  BaseDeclarativeTool,
+  BaseToolInvocation,
+  ToolCallConfirmationDetails,
+  ToolInvocation,
+  ToolResult,
+  Kind,
+} from '../tools/tools.js';
+import {
+  ModifiableDeclarativeTool,
+  ModifyContext,
+} from '../tools/modifiable-tool.js';
+
+class MockToolInvocation extends BaseToolInvocation<
+  { [key: string]: unknown },
+  ToolResult
+> {
+  constructor(
+    private readonly tool: MockTool,
+    params: { [key: string]: unknown },
+  ) {
+    super(params);
+  }
+
+  async execute(_abortSignal: AbortSignal): Promise<ToolResult> {
+    const result = this.tool.executeFn(this.params);
+    return (
+      result ?? {
+        llmContent: `Tool ${this.tool.name} executed successfully.`,
+        returnDisplay: `Tool ${this.tool.name} executed successfully.`,
+      }
+    );
+  }
+
+  override async shouldConfirmExecute(
+    _abortSignal: AbortSignal,
+  ): Promise<ToolCallConfirmationDetails | false> {
+    if (this.tool.shouldConfirm) {
+      return {
+        type: 'exec' as const,
+        title: `Confirm ${this.tool.displayName}`,
+        command: this.tool.name,
+        rootCommand: this.tool.name,
+        onConfirm: async () => {},
+      };
+    }
+    return false;
+  }
+
+  getDescription(): string {
+    return `A mock tool invocation for ${this.tool.name}`;
+  }
+}
+
+/**
+ * A highly configurable mock tool for testing purposes.
+ */
+export class MockTool extends BaseDeclarativeTool<
+  { [key: string]: unknown },
+  ToolResult
+> {
+  executeFn = vi.fn();
+  shouldConfirm = false;
+
+  constructor(
+    name = 'mock-tool',
+    displayName?: string,
+    description = 'A mock tool for testing.',
+    params = {
+      type: 'object',
+      properties: { param: { type: 'string' } },
+    },
+  ) {
+    super(name, displayName ?? name, description, Kind.Other, params);
+  }
+
+  protected createInvocation(params: {
+    [key: string]: unknown;
+  }): ToolInvocation<{ [key: string]: unknown }, ToolResult> {
+    return new MockToolInvocation(this, params);
+  }
+}
+
+export class MockModifiableToolInvocation extends BaseToolInvocation<
+  Record<string, unknown>,
+  ToolResult
+> {
+  constructor(
+    private readonly tool: MockModifiableTool,
+    params: Record<string, unknown>,
+  ) {
+    super(params);
+  }
+
+  async execute(_abortSignal: AbortSignal): Promise<ToolResult> {
+    const result = this.tool.executeFn(this.params);
+    return (
+      result ?? {
+        llmContent: `Tool ${this.tool.name} executed successfully.`,
+        returnDisplay: `Tool ${this.tool.name} executed successfully.`,
+      }
+    );
+  }
+
+  override async shouldConfirmExecute(
+    _abortSignal: AbortSignal,
+  ): Promise<ToolCallConfirmationDetails | false> {
+    if (this.tool.shouldConfirm) {
+      return {
+        type: 'edit',
+        title: 'Confirm Mock Tool',
+        fileName: 'test.txt',
+        filePath: 'test.txt',
+        fileDiff: 'diff',
+        originalContent: 'originalContent',
+        newContent: 'newContent',
+        onConfirm: async () => {},
+      };
+    }
+    return false;
+  }
+
+  getDescription(): string {
+    return `A mock modifiable tool invocation for ${this.tool.name}`;
+  }
+}
+
+/**
+ * Configurable mock modifiable tool for testing.
+ */
+export class MockModifiableTool
+  extends MockTool
+  implements ModifiableDeclarativeTool<Record<string, unknown>>
+{
+  constructor(name = 'mockModifiableTool') {
+    super(name);
+    this.shouldConfirm = true;
+  }
+
+  getModifyContext(
+    _abortSignal: AbortSignal,
+  ): ModifyContext<Record<string, unknown>> {
+    return {
+      getFilePath: () => 'test.txt',
+      getCurrentContent: async () => 'old content',
+      getProposedContent: async () => 'new content',
+      createUpdatedParams: (
+        _oldContent: string,
+        modifiedProposedContent: string,
+        _originalParams: Record<string, unknown>,
+      ) => ({ newContent: modifiedProposedContent }),
+    };
+  }
+
+  protected override createInvocation(
+    params: Record<string, unknown>,
+  ): ToolInvocation<Record<string, unknown>, ToolResult> {
+    return new MockModifiableToolInvocation(this, params);
+  }
+}

projects/ui/qwen-code/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,
+    });
+  });
+});

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

@@ -0,0 +1,65 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+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,
+  };
+}

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

@@ -0,0 +1,862 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+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,
+}));
+
+vi.mock('../core/client.js', () => ({
+  GeminiClient: vi.fn().mockImplementation(() => ({
+    generateJson: mockGenerateJson,
+  })),
+}));
+
+vi.mock('../utils/editor.js', () => ({
+  openDiff: mockOpenDiff,
+}));
+
+import { describe, it, expect, beforeEach, afterEach, vi, Mock } from 'vitest';
+import { applyReplacement, EditTool, EditToolParams } from './edit.js';
+import { FileDiff, ToolConfirmationOutcome } from './tools.js';
+import { ToolErrorType } from './tool-error.js';
+import path from 'path';
+import fs from 'fs';
+import os from 'os';
+import { ApprovalMode, Config } from '../config/config.js';
+import { Content, Part, SchemaUnion } from '@google/genai';
+import { createMockWorkspaceContext } from '../test-utils/mockWorkspaceContext.js';
+import { StandardFileSystemService } from '../services/fileSystemService.js';
+
+describe('EditTool', () => {
+  let tool: EditTool;
+  let tempDir: string;
+  let rootDir: string;
+  let mockConfig: Config;
+  let geminiClient: any;
+
+  beforeEach(() => {
+    vi.restoreAllMocks();
+    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'edit-tool-test-'));
+    rootDir = path.join(tempDir, 'root');
+    fs.mkdirSync(rootDir);
+
+    geminiClient = {
+      generateJson: mockGenerateJson, // mockGenerateJson is already defined and hoisted
+    };
+
+    mockConfig = {
+      getGeminiClient: vi.fn().mockReturnValue(geminiClient),
+      getTargetDir: () => rootDir,
+      getApprovalMode: vi.fn(),
+      setApprovalMode: vi.fn(),
+      getWorkspaceContext: () => createMockWorkspaceContext(rootDir),
+      getFileSystemService: () => new StandardFileSystemService(),
+      getIdeClient: () => undefined,
+      getIdeMode: () => 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:
+      getApiKey: () => 'test-api-key',
+      getModel: () => 'test-model',
+      getSandbox: () => false,
+      getDebugMode: () => false,
+      getQuestion: () => undefined,
+      getFullContext: () => false,
+      getToolDiscoveryCommand: () => undefined,
+      getToolCallCommand: () => undefined,
+      getMcpServerCommand: () => undefined,
+      getMcpServers: () => undefined,
+      getUserAgent: () => 'test-agent',
+      getUserMemory: () => '',
+      setUserMemory: vi.fn(),
+      getGeminiMdFileCount: () => 0,
+      setGeminiMdFileCount: vi.fn(),
+      getToolRegistry: () => ({}) as any, // Minimal mock for ToolRegistry
+    } as unknown as Config;
+
+    // Reset mocks before each test
+    (mockConfig.getApprovalMode as Mock).mockClear();
+    // Default to not skipping confirmation
+    (mockConfig.getApprovalMode as Mock).mockReturnValue(ApprovalMode.DEFAULT);
+
+    // Reset mocks and set default implementation for ensureCorrectEdit
+    mockEnsureCorrectEdit.mockReset();
+    mockEnsureCorrectEdit.mockImplementation(
+      async (_, currentContent, params) => {
+        let occurrences = 0;
+        if (params.old_string && currentContent) {
+          // Simple string counting for the mock
+          let index = currentContent.indexOf(params.old_string);
+          while (index !== -1) {
+            occurrences++;
+            index = currentContent.indexOf(params.old_string, index + 1);
+          }
+        } else if (params.old_string === '') {
+          occurrences = 0; // Creating a new file
+        }
+        return Promise.resolve({ params, occurrences });
+      },
+    );
+
+    // Default mock for generateJson to return the snippet unchanged
+    mockGenerateJson.mockReset();
+    mockGenerateJson.mockImplementation(
+      async (contents: Content[], schema: SchemaUnion) => {
+        // The problematic_snippet is the last part of the user's content
+        const userContent = contents.find((c: Content) => c.role === 'user');
+        let promptText = '';
+        if (userContent && userContent.parts) {
+          promptText = userContent.parts
+            .filter((p: Part) => typeof (p as any).text === 'string')
+            .map((p: Part) => (p as any).text)
+            .join('\n');
+        }
+        const snippetMatch = promptText.match(
+          /Problematic target snippet:\n```\n([\s\S]*?)\n```/,
+        );
+        const problematicSnippet =
+          snippetMatch && snippetMatch[1] ? snippetMatch[1] : '';
+
+        if (((schema as any).properties as any)?.corrected_target_snippet) {
+          return Promise.resolve({
+            corrected_target_snippet: problematicSnippet,
+          });
+        }
+        if (((schema as any).properties as any)?.corrected_new_string) {
+          // For new_string correction, we might need more sophisticated logic,
+          // but for now, returning original is a safe default if not specified by a test.
+          const originalNewStringMatch = promptText.match(
+            /original_new_string \(what was intended to replace original_old_string\):\n```\n([\s\S]*?)\n```/,
+          );
+          const originalNewString =
+            originalNewStringMatch && originalNewStringMatch[1]
+              ? originalNewStringMatch[1]
+              : '';
+          return Promise.resolve({ corrected_new_string: originalNewString });
+        }
+        return Promise.resolve({}); // Default empty object if schema doesn't match
+      },
+    );
+
+    tool = new EditTool(mockConfig);
+  });
+
+  afterEach(() => {
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  describe('applyReplacement', () => {
+    it('should return newString if isNewFile is true', () => {
+      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(applyReplacement(null, '', 'new', false)).toBe('new');
+    });
+
+    it('should return empty string if currentContent is null and oldString is not empty (defensive)', () => {
+      expect(applyReplacement(null, 'old', 'new', false)).toBe('');
+    });
+
+    it('should replace oldString with newString in currentContent', () => {
+      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(applyReplacement('hello world', '', 'new', false)).toBe(
+        'hello world',
+      );
+    });
+  });
+
+  describe('validateToolParams', () => {
+    it('should return null for valid params', () => {
+      const params: EditToolParams = {
+        file_path: path.join(rootDir, 'test.txt'),
+        old_string: 'old',
+        new_string: 'new',
+      };
+      expect(tool.validateToolParams(params)).toBeNull();
+    });
+
+    it('should return error for relative path', () => {
+      const params: EditToolParams = {
+        file_path: 'test.txt',
+        old_string: 'old',
+        new_string: 'new',
+      };
+      expect(tool.validateToolParams(params)).toMatch(
+        /File path must be absolute/,
+      );
+    });
+
+    it('should return error for path outside root', () => {
+      const params: EditToolParams = {
+        file_path: path.join(tempDir, 'outside-root.txt'),
+        old_string: 'old',
+        new_string: 'new',
+      };
+      const error = tool.validateToolParams(params);
+      expect(error).toContain(
+        'File path must be within one of the workspace directories',
+      );
+    });
+  });
+
+  describe('shouldConfirmExecute', () => {
+    const testFile = 'edit_me.txt';
+    let filePath: string;
+
+    beforeEach(() => {
+      filePath = path.join(rootDir, testFile);
+    });
+
+    it('should throw an error if params are invalid', async () => {
+      const params: EditToolParams = {
+        file_path: 'relative.txt',
+        old_string: 'old',
+        new_string: 'new',
+      };
+      expect(() => tool.build(params)).toThrow();
+    });
+
+    it('should request confirmation for valid edit', async () => {
+      fs.writeFileSync(filePath, 'some old content here');
+      const params: EditToolParams = {
+        file_path: filePath,
+        old_string: 'old',
+        new_string: 'new',
+      };
+      // ensureCorrectEdit will be called by shouldConfirmExecute
+      mockEnsureCorrectEdit.mockResolvedValueOnce({ params, occurrences: 1 });
+      const invocation = tool.build(params);
+      const confirmation = await invocation.shouldConfirmExecute(
+        new AbortController().signal,
+      );
+      expect(confirmation).toEqual(
+        expect.objectContaining({
+          title: `Confirm Edit: ${testFile}`,
+          fileName: testFile,
+          fileDiff: expect.any(String),
+        }),
+      );
+    });
+
+    it('should return false if old_string is not found (ensureCorrectEdit returns 0)', async () => {
+      fs.writeFileSync(filePath, 'some content here');
+      const params: EditToolParams = {
+        file_path: filePath,
+        old_string: 'not_found',
+        new_string: 'new',
+      };
+      mockEnsureCorrectEdit.mockResolvedValueOnce({ params, occurrences: 0 });
+      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 () => {
+      fs.writeFileSync(filePath, 'old old content here');
+      const params: EditToolParams = {
+        file_path: filePath,
+        old_string: 'old',
+        new_string: 'new',
+      };
+      mockEnsureCorrectEdit.mockResolvedValueOnce({ params, occurrences: 2 });
+      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 () => {
+      const newFileName = 'new_file.txt';
+      const newFilePath = path.join(rootDir, newFileName);
+      const params: EditToolParams = {
+        file_path: newFilePath,
+        old_string: '',
+        new_string: 'new file content',
+      };
+      // ensureCorrectEdit might not be called if old_string is empty,
+      // 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 invocation = tool.build(params);
+      const confirmation = await invocation.shouldConfirmExecute(
+        new AbortController().signal,
+      );
+      expect(confirmation).toEqual(
+        expect.objectContaining({
+          title: `Confirm Edit: ${newFileName}`,
+          fileName: newFileName,
+          fileDiff: expect.any(String),
+        }),
+      );
+    });
+
+    it('should use corrected params from ensureCorrectEdit for diff generation', async () => {
+      const originalContent = 'This is the original string to be replaced.';
+      const originalOldString = 'original string';
+      const originalNewString = 'new string';
+
+      const correctedOldString = 'original string to be replaced'; // More specific
+      const correctedNewString = 'completely new string'; // Different replacement
+      const expectedFinalContent = 'This is the completely new string.';
+
+      fs.writeFileSync(filePath, originalContent);
+      const params: EditToolParams = {
+        file_path: filePath,
+        old_string: originalOldString,
+        new_string: originalNewString,
+      };
+
+      // The main beforeEach already calls mockEnsureCorrectEdit.mockReset()
+      // Set a specific mock for this test case
+      let mockCalled = false;
+      mockEnsureCorrectEdit.mockImplementationOnce(
+        async (_, content, p, client) => {
+          mockCalled = true;
+          expect(content).toBe(originalContent);
+          expect(p).toBe(params);
+          expect(client).toBe(geminiClient);
+          return {
+            params: {
+              file_path: filePath,
+              old_string: correctedOldString,
+              new_string: correctedNewString,
+            },
+            occurrences: 1,
+          };
+        },
+      );
+      const invocation = tool.build(params);
+      const confirmation = (await invocation.shouldConfirmExecute(
+        new AbortController().signal,
+      )) as FileDiff;
+
+      expect(mockCalled).toBe(true); // Check if the mock implementation was run
+      // expect(mockEnsureCorrectEdit).toHaveBeenCalledWith(originalContent, params, expect.anything()); // Keep this commented for now
+      expect(confirmation).toEqual(
+        expect.objectContaining({
+          title: `Confirm Edit: ${testFile}`,
+          fileName: testFile,
+        }),
+      );
+      // Check that the diff is based on the corrected strings leading to the new state
+      expect(confirmation.fileDiff).toContain(`-${originalContent}`);
+      expect(confirmation.fileDiff).toContain(`+${expectedFinalContent}`);
+
+      // Verify that applying the correctedOldString and correctedNewString to originalContent
+      // indeed produces the expectedFinalContent, which is what the diff should reflect.
+      const patchedContent = originalContent.replace(
+        correctedOldString, // This was the string identified by ensureCorrectEdit for replacement
+        correctedNewString, // This was the string identified by ensureCorrectEdit as the replacement
+      );
+      expect(patchedContent).toBe(expectedFinalContent);
+    });
+  });
+
+  describe('execute', () => {
+    const testFile = 'execute_me.txt';
+    let filePath: string;
+
+    beforeEach(() => {
+      filePath = path.join(rootDir, testFile);
+      // Default for execute tests, can be overridden
+      mockEnsureCorrectEdit.mockImplementation(async (_, content, params) => {
+        let occurrences = 0;
+        if (params.old_string && content) {
+          let index = content.indexOf(params.old_string);
+          while (index !== -1) {
+            occurrences++;
+            index = content.indexOf(params.old_string, index + 1);
+          }
+        } else if (params.old_string === '') {
+          occurrences = 0;
+        }
+        return { params, occurrences };
+      });
+    });
+
+    it('should throw error if file path is not absolute', async () => {
+      const params: EditToolParams = {
+        file_path: 'relative.txt',
+        old_string: 'old',
+        new_string: 'new',
+      };
+      expect(() => tool.build(params)).toThrow(/File path must be absolute/);
+    });
+
+    it('should throw error if file path is empty', async () => {
+      const params: EditToolParams = {
+        file_path: '',
+        old_string: 'old',
+        new_string: 'new',
+      };
+      expect(() => tool.build(params)).toThrow(
+        /The 'file_path' parameter must be non-empty./,
+      );
+    });
+
+    it('should edit an existing file and return diff with fileName', async () => {
+      const initialContent = 'This is some old text.';
+      const newContent = 'This is some new text.'; // old -> new
+      fs.writeFileSync(filePath, initialContent, 'utf8');
+      const params: EditToolParams = {
+        file_path: filePath,
+        old_string: 'old',
+        new_string: 'new',
+      };
+
+      // Specific mock for this test's execution path in calculateEdit
+      // ensureCorrectEdit is NOT called by calculateEdit, only by shouldConfirmExecute
+      // So, the default mockEnsureCorrectEdit should correctly return 1 occurrence for 'old' in initialContent
+
+      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);
+      const display = result.returnDisplay as FileDiff;
+      expect(display.fileDiff).toMatch(initialContent);
+      expect(display.fileDiff).toMatch(newContent);
+      expect(display.fileName).toBe(testFile);
+    });
+
+    it('should create a new file if old_string is empty and file does not exist, and return created message', async () => {
+      const newFileName = 'brand_new_file.txt';
+      const newFilePath = path.join(rootDir, newFileName);
+      const fileContent = 'Content for the new file.';
+      const params: EditToolParams = {
+        file_path: newFilePath,
+        old_string: '',
+        new_string: fileContent,
+      };
+
+      (mockConfig.getApprovalMode as Mock).mockReturnValueOnce(
+        ApprovalMode.AUTO_EDIT,
+      );
+      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);
+      expect(fs.readFileSync(newFilePath, 'utf8')).toBe(fileContent);
+      expect(result.returnDisplay).toBe(`Created ${newFileName}`);
+    });
+
+    it('should return error if old_string is not found in file', async () => {
+      fs.writeFileSync(filePath, 'Some content.', 'utf8');
+      const params: EditToolParams = {
+        file_path: filePath,
+        old_string: 'nonexistent',
+        new_string: 'replacement',
+      };
+      // The default mockEnsureCorrectEdit will return 0 occurrences for 'nonexistent'
+      const invocation = tool.build(params);
+      const result = await invocation.execute(new AbortController().signal);
+      expect(result.llmContent).toMatch(
+        /0 occurrences found for old_string in/,
+      );
+      expect(result.returnDisplay).toMatch(
+        /Failed to edit, could not find the string to replace./,
+      );
+    });
+
+    it('should return error if multiple occurrences of old_string are found', async () => {
+      fs.writeFileSync(filePath, 'multiple old old strings', 'utf8');
+      const params: EditToolParams = {
+        file_path: filePath,
+        old_string: 'old',
+        new_string: 'new',
+      };
+      // The default mockEnsureCorrectEdit will return 2 occurrences for 'old'
+      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/,
+      );
+      expect(result.returnDisplay).toMatch(
+        /Failed to edit, expected 1 occurrence but found 2/,
+      );
+    });
+
+    it('should successfully replace multiple occurrences when expected_replacements specified', async () => {
+      fs.writeFileSync(filePath, 'old text old text old text', 'utf8');
+      const params: EditToolParams = {
+        file_path: filePath,
+        old_string: 'old',
+        new_string: 'new',
+        expected_replacements: 3,
+      };
+
+      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(
+        'new text new text new text',
+      );
+      const display = result.returnDisplay as FileDiff;
+      expect(display.fileDiff).toMatch(/old text old text old text/);
+      expect(display.fileDiff).toMatch(/new text new text new text/);
+      expect(display.fileName).toBe(testFile);
+    });
+
+    it('should return error if expected_replacements does not match actual occurrences', async () => {
+      fs.writeFileSync(filePath, 'old text old text', 'utf8');
+      const params: EditToolParams = {
+        file_path: filePath,
+        old_string: 'old',
+        new_string: 'new',
+        expected_replacements: 3, // Expecting 3 but only 2 exist
+      };
+      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/,
+      );
+      expect(result.returnDisplay).toMatch(
+        /Failed to edit, expected 3 occurrences but found 2/,
+      );
+    });
+
+    it('should return error if trying to create a file that already exists (empty old_string)', async () => {
+      fs.writeFileSync(filePath, 'Existing content', 'utf8');
+      const params: EditToolParams = {
+        file_path: filePath,
+        old_string: '',
+        new_string: 'new content',
+      };
+      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/,
+      );
+    });
+
+    it('should include modification message when proposed content is modified', async () => {
+      const initialContent = 'This is some old text.';
+      fs.writeFileSync(filePath, initialContent, 'utf8');
+      const params: EditToolParams = {
+        file_path: filePath,
+        old_string: 'old',
+        new_string: 'new',
+        modified_by_user: true,
+      };
+
+      (mockConfig.getApprovalMode as Mock).mockReturnValueOnce(
+        ApprovalMode.AUTO_EDIT,
+      );
+      const invocation = tool.build(params);
+      const result = await invocation.execute(new AbortController().signal);
+
+      expect(result.llmContent).toMatch(
+        /User modified the `new_string` content/,
+      );
+    });
+
+    it('should not include modification message when proposed content is not modified', async () => {
+      const initialContent = 'This is some old text.';
+      fs.writeFileSync(filePath, initialContent, 'utf8');
+      const params: EditToolParams = {
+        file_path: filePath,
+        old_string: 'old',
+        new_string: 'new',
+        modified_by_user: false,
+      };
+
+      (mockConfig.getApprovalMode as Mock).mockReturnValueOnce(
+        ApprovalMode.AUTO_EDIT,
+      );
+      const invocation = tool.build(params);
+      const result = await invocation.execute(new AbortController().signal);
+
+      expect(result.llmContent).not.toMatch(
+        /User modified the `new_string` content/,
+      );
+    });
+
+    it('should not include modification message when modified_by_user is not provided', async () => {
+      const initialContent = 'This is some old text.';
+      fs.writeFileSync(filePath, initialContent, 'utf8');
+      const params: EditToolParams = {
+        file_path: filePath,
+        old_string: 'old',
+        new_string: 'new',
+      };
+
+      (mockConfig.getApprovalMode as Mock).mockReturnValueOnce(
+        ApprovalMode.AUTO_EDIT,
+      );
+      const invocation = tool.build(params);
+      const result = await invocation.execute(new AbortController().signal);
+
+      expect(result.llmContent).not.toMatch(
+        /User modified the `new_string` content/,
+      );
+    });
+
+    it('should return error if old_string and new_string are identical', async () => {
+      const initialContent = 'This is some identical text.';
+      fs.writeFileSync(filePath, initialContent, 'utf8');
+      const params: EditToolParams = {
+        file_path: filePath,
+        old_string: 'identical',
+        new_string: 'identical',
+      };
+      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/);
+    });
+  });
+
+  describe('Error Scenarios', () => {
+    const testFile = 'error_test.txt';
+    let filePath: string;
+
+    beforeEach(() => {
+      filePath = path.join(rootDir, testFile);
+    });
+
+    it('should return FILE_NOT_FOUND error', async () => {
+      const params: EditToolParams = {
+        file_path: filePath,
+        old_string: 'any',
+        new_string: 'new',
+      };
+      const invocation = tool.build(params);
+      const result = await invocation.execute(new AbortController().signal);
+      expect(result.error?.type).toBe(ToolErrorType.FILE_NOT_FOUND);
+    });
+
+    it('should return ATTEMPT_TO_CREATE_EXISTING_FILE error', async () => {
+      fs.writeFileSync(filePath, 'existing content', 'utf8');
+      const params: EditToolParams = {
+        file_path: filePath,
+        old_string: '',
+        new_string: 'new content',
+      };
+      const invocation = tool.build(params);
+      const result = await invocation.execute(new AbortController().signal);
+      expect(result.error?.type).toBe(
+        ToolErrorType.ATTEMPT_TO_CREATE_EXISTING_FILE,
+      );
+    });
+
+    it('should return NO_OCCURRENCE_FOUND error', async () => {
+      fs.writeFileSync(filePath, 'content', 'utf8');
+      const params: EditToolParams = {
+        file_path: filePath,
+        old_string: 'not-found',
+        new_string: 'new',
+      };
+      const invocation = tool.build(params);
+      const result = await invocation.execute(new AbortController().signal);
+      expect(result.error?.type).toBe(ToolErrorType.EDIT_NO_OCCURRENCE_FOUND);
+    });
+
+    it('should return EXPECTED_OCCURRENCE_MISMATCH error', async () => {
+      fs.writeFileSync(filePath, 'one one two', 'utf8');
+      const params: EditToolParams = {
+        file_path: filePath,
+        old_string: 'one',
+        new_string: 'new',
+        expected_replacements: 3,
+      };
+      const invocation = tool.build(params);
+      const result = await invocation.execute(new AbortController().signal);
+      expect(result.error?.type).toBe(
+        ToolErrorType.EDIT_EXPECTED_OCCURRENCE_MISMATCH,
+      );
+    });
+
+    it('should return NO_CHANGE error', async () => {
+      fs.writeFileSync(filePath, 'content', 'utf8');
+      const params: EditToolParams = {
+        file_path: filePath,
+        old_string: 'content',
+        new_string: 'content',
+      };
+      const invocation = tool.build(params);
+      const result = await invocation.execute(new AbortController().signal);
+      expect(result.error?.type).toBe(ToolErrorType.EDIT_NO_CHANGE);
+    });
+
+    it('should throw INVALID_PARAMETERS error for relative path', async () => {
+      const params: EditToolParams = {
+        file_path: 'relative/path.txt',
+        old_string: 'a',
+        new_string: 'b',
+      };
+      expect(() => tool.build(params)).toThrow();
+    });
+
+    it('should return FILE_WRITE_FAILURE on write error', async () => {
+      fs.writeFileSync(filePath, 'content', 'utf8');
+      // Make file readonly to trigger a write error
+      fs.chmodSync(filePath, '444');
+
+      const params: EditToolParams = {
+        file_path: filePath,
+        old_string: 'content',
+        new_string: 'new content',
+      };
+      const invocation = tool.build(params);
+      const result = await invocation.execute(new AbortController().signal);
+      expect(result.error?.type).toBe(ToolErrorType.FILE_WRITE_FAILURE);
+    });
+  });
+
+  describe('getDescription', () => {
+    it('should return "No file changes to..." if old_string and new_string are the same', () => {
+      const testFileName = 'test.txt';
+      const params: EditToolParams = {
+        file_path: path.join(rootDir, testFileName),
+        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(invocation.getDescription()).toBe(
+        `No file changes to ${testFileName}`,
+      );
+    });
+
+    it('should return a snippet of old and new strings if they are different', () => {
+      const testFileName = 'test.txt';
+      const params: EditToolParams = {
+        file_path: path.join(rootDir, testFileName),
+        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(invocation.getDescription()).toBe(
+        `${testFileName}: this is the old string value => this is the new string value`,
+      );
+    });
+
+    it('should handle very short strings correctly in the description', () => {
+      const testFileName = 'short.txt';
+      const params: EditToolParams = {
+        file_path: path.join(rootDir, testFileName),
+        old_string: 'old',
+        new_string: 'new',
+      };
+      const invocation = tool.build(params);
+      expect(invocation.getDescription()).toBe(`${testFileName}: old => new`);
+    });
+
+    it('should truncate long strings in the description', () => {
+      const testFileName = 'long.txt';
+      const params: EditToolParams = {
+        file_path: path.join(rootDir, testFileName),
+        old_string:
+          'this is a very long old string that will definitely be truncated',
+        new_string:
+          'this is a very long new string that will also be truncated',
+      };
+      const invocation = tool.build(params);
+      expect(invocation.getDescription()).toBe(
+        `${testFileName}: this is a very long old string... => this is a very long new string...`,
+      );
+    });
+  });
+
+  describe('workspace boundary validation', () => {
+    it('should validate paths are within workspace root', () => {
+      const validPath = {
+        file_path: path.join(rootDir, 'file.txt'),
+        old_string: 'old',
+        new_string: 'new',
+      };
+      expect(tool.validateToolParams(validPath)).toBeNull();
+    });
+
+    it('should reject paths outside workspace root', () => {
+      const invalidPath = {
+        file_path: '/etc/passwd',
+        old_string: 'root',
+        new_string: 'hacked',
+      };
+      const error = tool.validateToolParams(invalidPath);
+      expect(error).toContain(
+        'File path must be within one of the workspace directories',
+      );
+      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).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 invocation = tool.build(params);
+      const confirmation = await invocation.shouldConfirmExecute(
+        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);
+    });
+  });
+});

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

@@ -0,0 +1,548 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+import * as Diff from 'diff';
+import {
+  BaseDeclarativeTool,
+  Kind,
+  ToolCallConfirmationDetails,
+  ToolConfirmationOutcome,
+  ToolEditConfirmationDetails,
+  ToolInvocation,
+  ToolLocation,
+  ToolResult,
+  ToolResultDisplay,
+} from './tools.js';
+import { ToolErrorType } from './tool-error.js';
+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, getDiffStat } from './diffOptions.js';
+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
+ */
+export interface EditToolParams {
+  /**
+   * The absolute path to the file to modify
+   */
+  file_path: string;
+
+  /**
+   * The text to replace
+   */
+  old_string: string;
+
+  /**
+   * The text to replace it with
+   */
+  new_string: string;
+
+  /**
+   * Number of replacements expected. Defaults to 1 if not specified.
+   * Use when you want to replace multiple occurrences.
+   */
+  expected_replacements?: number;
+
+  /**
+   * Whether the edit was modified manually by the user.
+   */
+  modified_by_user?: boolean;
+
+  /**
+   * Initially proposed string.
+   */
+  ai_proposed_string?: string;
+}
+
+interface CalculatedEdit {
+  currentContent: string | null;
+  newContent: string;
+  occurrences: number;
+  error?: { display: string; raw: string; type: ToolErrorType };
+  isNewFile: boolean;
+}
+
+class EditToolInvocation implements ToolInvocation<EditToolParams, ToolResult> {
+  constructor(
+    private readonly config: Config,
+    public params: EditToolParams,
+  ) {}
+
+  toolLocations(): ToolLocation[] {
+    return [{ path: this.params.file_path }];
+  }
+
+  /**
+   * Calculates the potential outcome of an edit operation.
+   * @param params Parameters for the edit operation
+   * @returns An object describing the potential edit outcome
+   * @throws File system errors if reading the file fails unexpectedly (e.g., permissions)
+   */
+  private async calculateEdit(
+    params: EditToolParams,
+    abortSignal: AbortSignal,
+  ): Promise<CalculatedEdit> {
+    const expectedReplacements = params.expected_replacements ?? 1;
+    let currentContent: string | null = null;
+    let fileExists = false;
+    let isNewFile = false;
+    let finalNewString = params.new_string;
+    let finalOldString = params.old_string;
+    let occurrences = 0;
+    let error:
+      | { display: string; raw: string; type: ToolErrorType }
+      | undefined = undefined;
+
+    try {
+      currentContent = await this.config
+        .getFileSystemService()
+        .readTextFile(params.file_path);
+      // Normalize line endings to LF for consistent processing.
+      currentContent = currentContent.replace(/\r\n/g, '\n');
+      fileExists = true;
+    } catch (err: unknown) {
+      if (!isNodeError(err) || err.code !== 'ENOENT') {
+        // Rethrow unexpected FS errors (permissions, etc.)
+        throw err;
+      }
+      fileExists = false;
+    }
+
+    if (params.old_string === '' && !fileExists) {
+      // Creating a new file
+      isNewFile = true;
+    } else if (!fileExists) {
+      // Trying to edit a nonexistent file (and old_string is not empty)
+      error = {
+        display: `File not found. Cannot apply edit. Use an empty old_string to create a new file.`,
+        raw: `File not found: ${params.file_path}`,
+        type: ToolErrorType.FILE_NOT_FOUND,
+      };
+    } else if (currentContent !== null) {
+      // Editing an existing file
+      const correctedEdit = await ensureCorrectEdit(
+        params.file_path,
+        currentContent,
+        params,
+        this.config.getGeminiClient(),
+        abortSignal,
+      );
+      finalOldString = correctedEdit.params.old_string;
+      finalNewString = correctedEdit.params.new_string;
+      occurrences = correctedEdit.occurrences;
+
+      if (params.old_string === '') {
+        // Error: Trying to create a file that already exists
+        error = {
+          display: `Failed to edit. Attempted to create a file that already exists.`,
+          raw: `File already exists, cannot create: ${params.file_path}`,
+          type: ToolErrorType.ATTEMPT_TO_CREATE_EXISTING_FILE,
+        };
+      } else if (occurrences === 0) {
+        error = {
+          display: `Failed to edit, could not find the string to replace.`,
+          raw: `Failed to edit, 0 occurrences found for old_string in ${params.file_path}. No edits made. The exact text in old_string was not found. Ensure you're not escaping content incorrectly and check whitespace, indentation, and context. Use ${ReadFileTool.Name} tool to verify.`,
+          type: ToolErrorType.EDIT_NO_OCCURRENCE_FOUND,
+        };
+      } else if (occurrences !== expectedReplacements) {
+        const occurrenceTerm =
+          expectedReplacements === 1 ? 'occurrence' : 'occurrences';
+
+        error = {
+          display: `Failed to edit, expected ${expectedReplacements} ${occurrenceTerm} but found ${occurrences}.`,
+          raw: `Failed to edit, Expected ${expectedReplacements} ${occurrenceTerm} but found ${occurrences} for old_string in file: ${params.file_path}`,
+          type: ToolErrorType.EDIT_EXPECTED_OCCURRENCE_MISMATCH,
+        };
+      } else if (finalOldString === finalNewString) {
+        error = {
+          display: `No changes to apply. The old_string and new_string are identical.`,
+          raw: `No changes to apply. The old_string and new_string are identical in file: ${params.file_path}`,
+          type: ToolErrorType.EDIT_NO_CHANGE,
+        };
+      }
+    } else {
+      // Should not happen if fileExists and no exception was thrown, but defensively:
+      error = {
+        display: `Failed to read content of file.`,
+        raw: `Failed to read content of existing file: ${params.file_path}`,
+        type: ToolErrorType.READ_CONTENT_FAILURE,
+      };
+    }
+
+    const newContent = applyReplacement(
+      currentContent,
+      finalOldString,
+      finalNewString,
+      isNewFile,
+    );
+
+    return {
+      currentContent,
+      newContent,
+      occurrences,
+      error,
+      isNewFile,
+    };
+  }
+
+  /**
+   * Handles the confirmation prompt for the Edit tool in the CLI.
+   * It needs to calculate the diff to show the user.
+   */
+  async shouldConfirmExecute(
+    abortSignal: AbortSignal,
+  ): Promise<ToolCallConfirmationDetails | false> {
+    if (this.config.getApprovalMode() === ApprovalMode.AUTO_EDIT) {
+      return false;
+    }
+
+    let editData: CalculatedEdit;
+    try {
+      editData = await this.calculateEdit(this.params, abortSignal);
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : String(error);
+      console.log(`Error preparing edit: ${errorMsg}`);
+      return false;
+    }
+
+    if (editData.error) {
+      console.log(`Error: ${editData.error.display}`);
+      return false;
+    }
+
+    const fileName = path.basename(this.params.file_path);
+    const fileDiff = Diff.createPatch(
+      fileName,
+      editData.currentContent ?? '',
+      editData.newContent,
+      'Current',
+      'Proposed',
+      DEFAULT_DIFF_OPTIONS,
+    );
+    const ideClient = this.config.getIdeClient();
+    const ideConfirmation =
+      this.config.getIdeMode() &&
+      ideClient?.getConnectionStatus().status === IDEConnectionStatus.Connected
+        ? ideClient.openDiff(this.params.file_path, editData.newContent)
+        : undefined;
+
+    const confirmationDetails: ToolEditConfirmationDetails = {
+      type: 'edit',
+      title: `Confirm Edit: ${shortenPath(makeRelative(this.params.file_path, this.config.getTargetDir()))}`,
+      fileName,
+      filePath: this.params.file_path,
+      fileDiff,
+      originalContent: editData.currentContent,
+      newContent: editData.newContent,
+      onConfirm: async (outcome: ToolConfirmationOutcome) => {
+        if (outcome === ToolConfirmationOutcome.ProceedAlways) {
+          this.config.setApprovalMode(ApprovalMode.AUTO_EDIT);
+        }
+
+        if (ideConfirmation) {
+          const result = await ideConfirmation;
+          if (result.status === 'accepted' && result.content) {
+            // 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.
+            this.params.old_string = editData.currentContent ?? '';
+            this.params.new_string = result.content;
+          }
+        }
+      },
+      ideConfirmation,
+    };
+    return confirmationDetails;
+  }
+
+  getDescription(): string {
+    const relativePath = makeRelative(
+      this.params.file_path,
+      this.config.getTargetDir(),
+    );
+    if (this.params.old_string === '') {
+      return `Create ${shortenPath(relativePath)}`;
+    }
+
+    const oldStringSnippet =
+      this.params.old_string.split('\n')[0].substring(0, 30) +
+      (this.params.old_string.length > 30 ? '...' : '');
+    const newStringSnippet =
+      this.params.new_string.split('\n')[0].substring(0, 30) +
+      (this.params.new_string.length > 30 ? '...' : '');
+
+    if (this.params.old_string === this.params.new_string) {
+      return `No file changes to ${shortenPath(relativePath)}`;
+    }
+    return `${shortenPath(relativePath)}: ${oldStringSnippet} => ${newStringSnippet}`;
+  }
+
+  /**
+   * Executes the edit operation with the given parameters.
+   * @param params Parameters for the edit operation
+   * @returns Result of the edit operation
+   */
+  async execute(signal: AbortSignal): Promise<ToolResult> {
+    let editData: CalculatedEdit;
+    try {
+      editData = await this.calculateEdit(this.params, signal);
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : String(error);
+      return {
+        llmContent: `Error preparing edit: ${errorMsg}`,
+        returnDisplay: `Error preparing edit: ${errorMsg}`,
+        error: {
+          message: errorMsg,
+          type: ToolErrorType.EDIT_PREPARATION_FAILURE,
+        },
+      };
+    }
+
+    if (editData.error) {
+      return {
+        llmContent: editData.error.raw,
+        returnDisplay: `Error: ${editData.error.display}`,
+        error: {
+          message: editData.error.raw,
+          type: editData.error.type,
+        },
+      };
+    }
+
+    try {
+      this.ensureParentDirectoriesExist(this.params.file_path);
+      await this.config
+        .getFileSystemService()
+        .writeTextFile(this.params.file_path, editData.newContent);
+
+      let displayResult: ToolResultDisplay;
+      if (editData.isNewFile) {
+        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(this.params.file_path);
+        const fileDiff = Diff.createPatch(
+          fileName,
+          editData.currentContent ?? '', // Should not be null here if not isNewFile
+          editData.newContent,
+          'Current',
+          '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,
+        };
+      }
+
+      const llmSuccessMessageParts = [
+        editData.isNewFile
+          ? `Created new file: ${this.params.file_path} with provided content.`
+          : `Successfully modified file: ${this.params.file_path} (${editData.occurrences} replacements).`,
+      ];
+      if (this.params.modified_by_user) {
+        llmSuccessMessageParts.push(
+          `User modified the \`new_string\` content to be: ${this.params.new_string}.`,
+        );
+      }
+
+      return {
+        llmContent: llmSuccessMessageParts.join(' '),
+        returnDisplay: displayResult,
+      };
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : String(error);
+      return {
+        llmContent: `Error executing edit: ${errorMsg}`,
+        returnDisplay: `Error writing file: ${errorMsg}`,
+        error: {
+          message: errorMsg,
+          type: ToolErrorType.FILE_WRITE_FAILURE,
+        },
+      };
+    }
+  }
+
+  /**
+   * Creates parent directories if they don't exist
+   */
+  private ensureParentDirectoriesExist(filePath: string): void {
+    const dirName = path.dirname(filePath);
+    if (!fs.existsSync(dirName)) {
+      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.`,
+      Kind.Edit,
+      {
+        properties: {
+          file_path: {
+            description:
+              "The absolute path to the file to modify. Must start with '/'.",
+            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: '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: 'string',
+          },
+          expected_replacements: {
+            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: 'object',
+      },
+    );
+  }
+
+  /**
+   * Validates the parameters for the Edit tool
+   * @param params Parameters to validate
+   * @returns Error message string or null if valid
+   */
+  protected override validateToolParamValues(
+    params: EditToolParams,
+  ): string | null {
+    if (!params.file_path) {
+      return "The 'file_path' parameter must be non-empty.";
+    }
+
+    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 {
+      getFilePath: (params: EditToolParams) => params.file_path,
+      getCurrentContent: async (params: EditToolParams): Promise<string> => {
+        try {
+          return this.config
+            .getFileSystemService()
+            .readTextFile(params.file_path);
+        } catch (err) {
+          if (!isNodeError(err) || err.code !== 'ENOENT') throw err;
+          return '';
+        }
+      },
+      getProposedContent: async (params: EditToolParams): Promise<string> => {
+        try {
+          const currentContent = await this.config
+            .getFileSystemService()
+            .readTextFile(params.file_path);
+          return applyReplacement(
+            currentContent,
+            params.old_string,
+            params.new_string,
+            params.old_string === '' && currentContent === '',
+          );
+        } catch (err) {
+          if (!isNodeError(err) || err.code !== 'ENOENT') throw err;
+          return '';
+        }
+      },
+      createUpdatedParams: (
+        oldContent: string,
+        modifiedProposedContent: string,
+        originalParams: EditToolParams,
+      ): EditToolParams => {
+        const content = originalParams.new_string;
+        return {
+          ...originalParams,
+          ai_proposed_string: content,
+          old_string: oldContent,
+          new_string: modifiedProposedContent,
+          modified_by_user: true,
+        };
+      },
+    };
+  }
+}

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

@@ -0,0 +1,455 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { GlobTool, GlobToolParams, GlobPath, sortFileEntries } from './glob.js';
+import { partListUnionToString } from '../core/geminiRequest.js';
+import path from 'path';
+import fs from 'fs/promises';
+import os from 'os';
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { FileDiscoveryService } from '../services/fileDiscoveryService.js';
+import { Config } from '../config/config.js';
+import { createMockWorkspaceContext } from '../test-utils/mockWorkspaceContext.js';
+
+describe('GlobTool', () => {
+  let tempRootDir: string; // This will be the rootDirectory for the GlobTool instance
+  let globTool: GlobTool;
+  const abortSignal = new AbortController().signal;
+
+  // Mock config for testing
+  const mockConfig = {
+    getFileService: () => new FileDiscoveryService(tempRootDir),
+    getFileFilteringRespectGitIgnore: () => true,
+    getTargetDir: () => tempRootDir,
+    getWorkspaceContext: () => createMockWorkspaceContext(tempRootDir),
+  } as unknown as Config;
+
+  beforeEach(async () => {
+    // Create a unique root directory for each test run
+    tempRootDir = await fs.mkdtemp(path.join(os.tmpdir(), 'glob-tool-root-'));
+    globTool = new GlobTool(mockConfig);
+
+    // Create some test files and directories within this root
+    // Top-level files
+    await fs.writeFile(path.join(tempRootDir, 'fileA.txt'), 'contentA');
+    await fs.writeFile(path.join(tempRootDir, 'FileB.TXT'), 'contentB'); // Different case for testing
+
+    // Subdirectory and files within it
+    await fs.mkdir(path.join(tempRootDir, 'sub'));
+    await fs.writeFile(path.join(tempRootDir, 'sub', 'fileC.md'), 'contentC');
+    await fs.writeFile(path.join(tempRootDir, 'sub', 'FileD.MD'), 'contentD'); // Different case
+
+    // Deeper subdirectory
+    await fs.mkdir(path.join(tempRootDir, 'sub', 'deep'));
+    await fs.writeFile(
+      path.join(tempRootDir, 'sub', 'deep', 'fileE.log'),
+      'contentE',
+    );
+
+    // Files for mtime sorting test
+    await fs.writeFile(path.join(tempRootDir, 'older.sortme'), 'older_content');
+    // Ensure a noticeable difference in modification time
+    await new Promise((resolve) => setTimeout(resolve, 50));
+    await fs.writeFile(path.join(tempRootDir, 'newer.sortme'), 'newer_content');
+  });
+
+  afterEach(async () => {
+    // Clean up the temporary root directory
+    await fs.rm(tempRootDir, { recursive: true, force: true });
+  });
+
+  describe('execute', () => {
+    it('should find files matching a simple pattern in the root', async () => {
+      const params: GlobToolParams = { pattern: '*.txt' };
+      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'));
+      expect(result.returnDisplay).toBe('Found 2 matching file(s)');
+    });
+
+    it('should find files case-sensitively when case_sensitive is true', async () => {
+      const params: GlobToolParams = { pattern: '*.txt', case_sensitive: true };
+      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(
+        path.join(tempRootDir, 'FileB.TXT'),
+      );
+    });
+
+    it('should find files case-insensitively by default (pattern: *.TXT)', async () => {
+      const params: GlobToolParams = { pattern: '*.TXT' };
+      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'));
+    });
+
+    it('should find files case-insensitively when case_sensitive is false (pattern: *.TXT)', async () => {
+      const params: GlobToolParams = {
+        pattern: '*.TXT',
+        case_sensitive: false,
+      };
+      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'));
+    });
+
+    it('should find files using a pattern that includes a subdirectory', async () => {
+      const params: GlobToolParams = { pattern: 'sub/*.md' };
+      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'),
+      );
+      expect(result.llmContent).toContain(
+        path.join(tempRootDir, 'sub', 'FileD.MD'),
+      );
+    });
+
+    it('should find files in a specified relative path (relative to rootDir)', async () => {
+      const params: GlobToolParams = { pattern: '*.md', path: 'sub' };
+      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'),
+      );
+      expect(result.llmContent).toContain(
+        path.join(tempRootDir, 'sub', 'FileD.MD'),
+      );
+    });
+
+    it('should find files using a deep globstar pattern (e.g., **/*.log)', async () => {
+      const params: GlobToolParams = { pattern: '**/*.log' };
+      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'),
+      );
+    });
+
+    it('should return "No files found" message when pattern matches nothing', async () => {
+      const params: GlobToolParams = { pattern: '*.nonexistent' };
+      const invocation = globTool.build(params);
+      const result = await invocation.execute(abortSignal);
+      expect(result.llmContent).toContain(
+        'No files found matching pattern "*.nonexistent"',
+      );
+      expect(result.returnDisplay).toBe('No files found');
+    });
+
+    it('should find files with special characters in the name', async () => {
+      await fs.writeFile(path.join(tempRootDir, 'file[1].txt'), 'content');
+      const params: GlobToolParams = { pattern: 'file[1].txt' };
+      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, 'file[1].txt'),
+      );
+    });
+
+    it('should find files with special characters like [] and () in the path', async () => {
+      const filePath = path.join(
+        tempRootDir,
+        'src/app/[test]/(dashboard)/testing/components/code.tsx',
+      );
+      await fs.mkdir(path.dirname(filePath), { recursive: true });
+      await fs.writeFile(filePath, 'content');
+
+      const params: GlobToolParams = {
+        pattern: 'src/app/[test]/(dashboard)/testing/components/code.tsx',
+      };
+      const invocation = globTool.build(params);
+      const result = await invocation.execute(abortSignal);
+      expect(result.llmContent).toContain('Found 1 file(s)');
+      expect(result.llmContent).toContain(filePath);
+    });
+
+    it('should correctly sort files by modification time (newest first)', async () => {
+      const params: GlobToolParams = { pattern: '*.sortme' };
+      const invocation = globTool.build(params);
+      const result = await invocation.execute(abortSignal);
+      const llmContent = partListUnionToString(result.llmContent);
+
+      expect(llmContent).toContain('Found 2 file(s)');
+      // Ensure llmContent is a string for TypeScript type checking
+      expect(typeof llmContent).toBe('string');
+
+      const filesListed = llmContent
+        .trim()
+        .split(/\r?\n/)
+        .slice(1)
+        .map((line) => line.trim())
+        .filter(Boolean);
+
+      expect(filesListed).toHaveLength(2);
+      expect(path.resolve(filesListed[0])).toBe(
+        path.resolve(tempRootDir, 'newer.sortme'),
+      );
+      expect(path.resolve(filesListed[1])).toBe(
+        path.resolve(tempRootDir, 'older.sortme'),
+      );
+    });
+  });
+
+  describe('validateToolParams', () => {
+    it('should return null for valid parameters (pattern only)', () => {
+      const params: GlobToolParams = { pattern: '*.js' };
+      expect(globTool.validateToolParams(params)).toBeNull();
+    });
+
+    it('should return null for valid parameters (pattern and path)', () => {
+      const params: GlobToolParams = { pattern: '*.js', path: 'sub' };
+      expect(globTool.validateToolParams(params)).toBeNull();
+    });
+
+    it('should return null for valid parameters (pattern, path, and case_sensitive)', () => {
+      const params: GlobToolParams = {
+        pattern: '*.js',
+        path: 'sub',
+        case_sensitive: true,
+      };
+      expect(globTool.validateToolParams(params)).toBeNull();
+    });
+
+    it('should return error if pattern is missing (schema validation)', () => {
+      // Need to correctly define this as an object without pattern
+      const params = { path: '.' };
+      // @ts-expect-error - We're intentionally creating invalid params for testing
+      expect(globTool.validateToolParams(params)).toBe(
+        `params must have required property 'pattern'`,
+      );
+    });
+
+    it('should return error if pattern is an empty string', () => {
+      const params: GlobToolParams = { pattern: '' };
+      expect(globTool.validateToolParams(params)).toContain(
+        "The 'pattern' parameter cannot be empty.",
+      );
+    });
+
+    it('should return error if pattern is only whitespace', () => {
+      const params: GlobToolParams = { pattern: '   ' };
+      expect(globTool.validateToolParams(params)).toContain(
+        "The 'pattern' parameter cannot be empty.",
+      );
+    });
+
+    it('should return error if path is provided but is not a string (schema validation)', () => {
+      const params = {
+        pattern: '*.ts',
+        path: 123,
+      };
+      // @ts-expect-error - We're intentionally creating invalid params for testing
+      expect(globTool.validateToolParams(params)).toBe(
+        'params/path must be string',
+      );
+    });
+
+    it('should return error if case_sensitive is provided but is not a boolean (schema validation)', () => {
+      const params = {
+        pattern: '*.ts',
+        case_sensitive: 'true',
+      };
+      // @ts-expect-error - We're intentionally creating invalid params for testing
+      expect(globTool.validateToolParams(params)).toBe(
+        'params/case_sensitive must be boolean',
+      );
+    });
+
+    it("should return error if search path resolves outside the tool's root directory", () => {
+      // Create a globTool instance specifically for this test, with a deeper root
+      tempRootDir = path.join(tempRootDir, 'sub');
+      const specificGlobTool = new GlobTool(mockConfig);
+      // const params: GlobToolParams = { pattern: '*.txt', path: '..' }; // This line is unused and will be removed.
+      // This should be fine as tempRootDir is still within the original tempRootDir (the parent of deeperRootDir)
+      // Let's try to go further up.
+      const paramsOutside: GlobToolParams = {
+        pattern: '*.txt',
+        path: '../../../../../../../../../../tmp', // Definitely outside
+      };
+      expect(specificGlobTool.validateToolParams(paramsOutside)).toContain(
+        'resolves outside the allowed workspace directories',
+      );
+    });
+
+    it('should return error if specified search path does not exist', async () => {
+      const params: GlobToolParams = {
+        pattern: '*.txt',
+        path: 'nonexistent_subdir',
+      };
+      expect(globTool.validateToolParams(params)).toContain(
+        'Search path does not exist',
+      );
+    });
+
+    it('should return error if specified search path is a file, not a directory', async () => {
+      const params: GlobToolParams = { pattern: '*.txt', path: 'fileA.txt' };
+      expect(globTool.validateToolParams(params)).toContain(
+        'Search path is not a directory',
+      );
+    });
+  });
+
+  describe('workspace boundary validation', () => {
+    it('should validate search paths are within workspace boundaries', () => {
+      const validPath = { pattern: '*.ts', path: 'sub' };
+      const invalidPath = { pattern: '*.ts', path: '../..' };
+
+      expect(globTool.validateToolParams(validPath)).toBeNull();
+      expect(globTool.validateToolParams(invalidPath)).toContain(
+        'resolves outside the allowed workspace directories',
+      );
+    });
+
+    it('should provide clear error messages when path is outside workspace', () => {
+      const invalidPath = { pattern: '*.ts', path: '/etc' };
+      const error = globTool.validateToolParams(invalidPath);
+
+      expect(error).toContain(
+        'resolves outside the allowed workspace directories',
+      );
+      expect(error).toContain(tempRootDir);
+    });
+
+    it('should work with paths in workspace subdirectories', async () => {
+      const params: GlobToolParams = { pattern: '*.md', path: 'sub' };
+      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');
+      expect(result.llmContent).toContain('FileD.MD');
+    });
+  });
+});
+
+describe('sortFileEntries', () => {
+  const nowTimestamp = new Date('2024-01-15T12:00:00.000Z').getTime();
+  const oneDayInMs = 24 * 60 * 60 * 1000;
+
+  const createFileEntry = (fullpath: string, mtimeDate: Date): GlobPath => ({
+    fullpath: () => fullpath,
+    mtimeMs: mtimeDate.getTime(),
+  });
+
+  it('should sort a mix of recent and older files correctly', () => {
+    const recentTime1 = new Date(nowTimestamp - 1 * 60 * 60 * 1000); // 1 hour ago
+    const recentTime2 = new Date(nowTimestamp - 2 * 60 * 60 * 1000); // 2 hours ago
+    const olderTime1 = new Date(
+      nowTimestamp - (oneDayInMs + 1 * 60 * 60 * 1000),
+    ); // 25 hours ago
+    const olderTime2 = new Date(
+      nowTimestamp - (oneDayInMs + 2 * 60 * 60 * 1000),
+    ); // 26 hours ago
+
+    const entries: GlobPath[] = [
+      createFileEntry('older_zebra.txt', olderTime2),
+      createFileEntry('recent_alpha.txt', recentTime1),
+      createFileEntry('older_apple.txt', olderTime1),
+      createFileEntry('recent_beta.txt', recentTime2),
+      createFileEntry('older_banana.txt', olderTime1), // Same mtime as apple
+    ];
+
+    const sorted = sortFileEntries(entries, nowTimestamp, oneDayInMs);
+    const sortedPaths = sorted.map((e) => e.fullpath());
+
+    expect(sortedPaths).toEqual([
+      'recent_alpha.txt', // Recent, newest
+      'recent_beta.txt', // Recent, older
+      'older_apple.txt', // Older, alphabetical
+      'older_banana.txt', // Older, alphabetical
+      'older_zebra.txt', // Older, alphabetical
+    ]);
+  });
+
+  it('should sort only recent files by mtime descending', () => {
+    const recentTime1 = new Date(nowTimestamp - 1000); // Newest
+    const recentTime2 = new Date(nowTimestamp - 2000);
+    const recentTime3 = new Date(nowTimestamp - 3000); // Oldest recent
+
+    const entries: GlobPath[] = [
+      createFileEntry('c.txt', recentTime2),
+      createFileEntry('a.txt', recentTime3),
+      createFileEntry('b.txt', recentTime1),
+    ];
+    const sorted = sortFileEntries(entries, nowTimestamp, oneDayInMs);
+    expect(sorted.map((e) => e.fullpath())).toEqual([
+      'b.txt',
+      'c.txt',
+      'a.txt',
+    ]);
+  });
+
+  it('should sort only older files alphabetically by path', () => {
+    const olderTime = new Date(nowTimestamp - 2 * oneDayInMs); // All equally old
+    const entries: GlobPath[] = [
+      createFileEntry('zebra.txt', olderTime),
+      createFileEntry('apple.txt', olderTime),
+      createFileEntry('banana.txt', olderTime),
+    ];
+    const sorted = sortFileEntries(entries, nowTimestamp, oneDayInMs);
+    expect(sorted.map((e) => e.fullpath())).toEqual([
+      'apple.txt',
+      'banana.txt',
+      'zebra.txt',
+    ]);
+  });
+
+  it('should handle an empty array', () => {
+    const entries: GlobPath[] = [];
+    const sorted = sortFileEntries(entries, nowTimestamp, oneDayInMs);
+    expect(sorted).toEqual([]);
+  });
+
+  it('should correctly sort files when mtimes are identical for older files', () => {
+    const olderTime = new Date(nowTimestamp - 2 * oneDayInMs);
+    const entries: GlobPath[] = [
+      createFileEntry('b.txt', olderTime),
+      createFileEntry('a.txt', olderTime),
+    ];
+    const sorted = sortFileEntries(entries, nowTimestamp, oneDayInMs);
+    expect(sorted.map((e) => e.fullpath())).toEqual(['a.txt', 'b.txt']);
+  });
+
+  it('should correctly sort files when mtimes are identical for recent files (maintaining mtime sort)', () => {
+    const recentTime = new Date(nowTimestamp - 1000);
+    const entries: GlobPath[] = [
+      createFileEntry('b.txt', recentTime),
+      createFileEntry('a.txt', recentTime),
+    ];
+    const sorted = sortFileEntries(entries, nowTimestamp, oneDayInMs);
+    expect(sorted.map((e) => e.fullpath())).toContain('a.txt');
+    expect(sorted.map((e) => e.fullpath())).toContain('b.txt');
+    expect(sorted.length).toBe(2);
+  });
+
+  it('should use recencyThresholdMs parameter correctly', () => {
+    const justOverThreshold = new Date(nowTimestamp - (1000 + 1)); // Barely older
+    const justUnderThreshold = new Date(nowTimestamp - (1000 - 1)); // Barely recent
+    const customThresholdMs = 1000; // 1 second
+
+    const entries: GlobPath[] = [
+      createFileEntry('older_file.txt', justOverThreshold),
+      createFileEntry('recent_file.txt', justUnderThreshold),
+    ];
+    const sorted = sortFileEntries(entries, nowTimestamp, customThresholdMs);
+    expect(sorted.map((e) => e.fullpath())).toEqual([
+      'recent_file.txt',
+      'older_file.txt',
+    ]);
+  });
+});