Add files using upload-large-folder tool

projects/ui/qwen-code/packages/core/src/__mocks__/fs/promises.ts

@@ -0,0 +1,48 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { vi } from 'vitest';
+import * as actualFsPromises from 'node:fs/promises';
+
+const readFileMock = vi.fn();
+
+// Export a control object so tests can access and manipulate the mock
+export const mockControl = {
+  mockReadFile: readFileMock,
+};
+
+// Export all other functions from the actual fs/promises module
+export const {
+  access,
+  appendFile,
+  chmod,
+  chown,
+  copyFile,
+  cp,
+  lchmod,
+  lchown,
+  link,
+  lstat,
+  mkdir,
+  open,
+  opendir,
+  readdir,
+  readlink,
+  realpath,
+  rename,
+  rmdir,
+  rm,
+  stat,
+  symlink,
+  truncate,
+  unlink,
+  utimes,
+  watch,
+  writeFile,
+} = actualFsPromises;
+
+// Override readFile with our mock
+export const readFile = readFileMock;

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

@@ -0,0 +1,350 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { OpenAIContentGenerator } from '../openaiContentGenerator.js';
+import { Config } from '../../config/config.js';
+import { AuthType } from '../contentGenerator.js';
+import OpenAI from 'openai';
+
+// Mock OpenAI
+vi.mock('openai');
+
+// Mock logger modules
+vi.mock('../../telemetry/loggers.js', () => ({
+  logApiResponse: vi.fn(),
+  logApiError: vi.fn(),
+}));
+
+vi.mock('../../utils/openaiLogger.js', () => ({
+  openaiLogger: {
+    logInteraction: vi.fn(),
+  },
+}));
+
+describe('OpenAIContentGenerator Timeout Handling', () => {
+  let generator: OpenAIContentGenerator;
+  let mockConfig: Config;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  let mockOpenAIClient: any;
+
+  beforeEach(() => {
+    // Reset mocks
+    vi.clearAllMocks();
+
+    // Mock environment variables
+    vi.stubEnv('OPENAI_BASE_URL', '');
+
+    // Mock config
+    mockConfig = {
+      getContentGeneratorConfig: vi.fn().mockReturnValue({
+        authType: 'openai',
+      }),
+      getCliVersion: vi.fn().mockReturnValue('1.0.0'),
+    } as unknown as Config;
+
+    // Mock OpenAI client
+    mockOpenAIClient = {
+      chat: {
+        completions: {
+          create: vi.fn(),
+        },
+      },
+    };
+
+    vi.mocked(OpenAI).mockImplementation(() => mockOpenAIClient);
+
+    // Create generator instance
+    const contentGeneratorConfig = {
+      model: 'gpt-4',
+      apiKey: 'test-key',
+      authType: AuthType.USE_OPENAI,
+    };
+    generator = new OpenAIContentGenerator(contentGeneratorConfig, mockConfig);
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  describe('timeout error identification through actual requests', () => {
+    it('should handle various timeout error formats correctly', async () => {
+      const timeoutErrors = [
+        new Error('Request timeout'),
+        new Error('Connection timed out'),
+        new Error('ETIMEDOUT'),
+        Object.assign(new Error('Network error'), { code: 'ETIMEDOUT' }),
+        Object.assign(new Error('Socket error'), { code: 'ESOCKETTIMEDOUT' }),
+        Object.assign(new Error('API error'), { type: 'timeout' }),
+        new Error('request timed out'),
+        new Error('deadline exceeded'),
+      ];
+
+      const request = {
+        contents: [{ role: 'user' as const, parts: [{ text: 'Hello' }] }],
+        model: 'gpt-4',
+      };
+
+      for (const error of timeoutErrors) {
+        mockOpenAIClient.chat.completions.create.mockRejectedValueOnce(error);
+
+        try {
+          await generator.generateContent(request, 'test-prompt-id');
+        } catch (thrownError: unknown) {
+          // Should contain timeout-specific messaging and troubleshooting tips
+          const errorMessage =
+            thrownError instanceof Error
+              ? thrownError.message
+              : String(thrownError);
+          expect(errorMessage).toMatch(
+            /timeout after \d+s|Troubleshooting tips:/,
+          );
+        }
+      }
+    });
+
+    it('should handle non-timeout errors without timeout messaging', async () => {
+      const nonTimeoutErrors = [
+        new Error('Invalid API key'),
+        new Error('Rate limit exceeded'),
+        new Error('Model not found'),
+        Object.assign(new Error('Auth error'), { code: 'INVALID_REQUEST' }),
+        Object.assign(new Error('API error'), { type: 'authentication_error' }),
+      ];
+
+      const request = {
+        contents: [{ role: 'user' as const, parts: [{ text: 'Hello' }] }],
+        model: 'gpt-4',
+      };
+
+      for (const error of nonTimeoutErrors) {
+        mockOpenAIClient.chat.completions.create.mockRejectedValueOnce(error);
+
+        try {
+          await generator.generateContent(request, 'test-prompt-id');
+        } catch (thrownError: unknown) {
+          // Should NOT contain timeout-specific messaging
+          const errorMessage =
+            thrownError instanceof Error
+              ? thrownError.message
+              : String(thrownError);
+          expect(errorMessage).not.toMatch(/timeout after \d+s/);
+          expect(errorMessage).not.toMatch(/Troubleshooting tips:/);
+          // Should preserve the original error message
+          expect(errorMessage).toMatch(new RegExp(error.message));
+        }
+      }
+    });
+  });
+
+  describe('generateContent timeout handling', () => {
+    it('should handle timeout errors with helpful message', async () => {
+      // Mock timeout error
+      const timeoutError = new Error('Request timeout');
+      mockOpenAIClient.chat.completions.create.mockRejectedValue(timeoutError);
+
+      const request = {
+        contents: [{ role: 'user' as const, parts: [{ text: 'Hello' }] }],
+        model: 'gpt-4',
+      };
+
+      await expect(
+        generator.generateContent(request, 'test-prompt-id'),
+      ).rejects.toThrow(
+        /Request timeout after \d+s\. Try reducing input length or increasing timeout in config\./,
+      );
+    });
+
+    it('should handle non-timeout errors normally', async () => {
+      // Mock non-timeout error
+      const apiError = new Error('Invalid API key');
+      mockOpenAIClient.chat.completions.create.mockRejectedValue(apiError);
+
+      const request = {
+        contents: [{ role: 'user' as const, parts: [{ text: 'Hello' }] }],
+        model: 'gpt-4',
+      };
+
+      await expect(
+        generator.generateContent(request, 'test-prompt-id'),
+      ).rejects.toThrow('Invalid API key');
+    });
+
+    it('should include troubleshooting tips for timeout errors', async () => {
+      const timeoutError = new Error('Connection timed out');
+      mockOpenAIClient.chat.completions.create.mockRejectedValue(timeoutError);
+
+      const request = {
+        contents: [{ role: 'user' as const, parts: [{ text: 'Hello' }] }],
+        model: 'gpt-4',
+      };
+
+      try {
+        await generator.generateContent(request, 'test-prompt-id');
+      } catch (error: unknown) {
+        const errorMessage =
+          error instanceof Error ? error.message : String(error);
+        expect(errorMessage).toContain('Troubleshooting tips:');
+        expect(errorMessage).toContain('Reduce input length or complexity');
+        expect(errorMessage).toContain('Increase timeout in config');
+        expect(errorMessage).toContain('Check network connectivity');
+        expect(errorMessage).toContain('Consider using streaming mode');
+      }
+    });
+  });
+
+  describe('generateContentStream timeout handling', () => {
+    it('should handle streaming timeout errors', async () => {
+      const timeoutError = new Error('Streaming timeout');
+      mockOpenAIClient.chat.completions.create.mockRejectedValue(timeoutError);
+
+      const request = {
+        contents: [{ role: 'user' as const, parts: [{ text: 'Hello' }] }],
+        model: 'gpt-4',
+      };
+
+      await expect(
+        generator.generateContentStream(request, 'test-prompt-id'),
+      ).rejects.toThrow(
+        /Streaming setup timeout after \d+s\. Try reducing input length or increasing timeout in config\./,
+      );
+    });
+
+    it('should include streaming-specific troubleshooting tips', async () => {
+      const timeoutError = new Error('request timed out');
+      mockOpenAIClient.chat.completions.create.mockRejectedValue(timeoutError);
+
+      const request = {
+        contents: [{ role: 'user' as const, parts: [{ text: 'Hello' }] }],
+        model: 'gpt-4',
+      };
+
+      try {
+        await generator.generateContentStream(request, 'test-prompt-id');
+      } catch (error: unknown) {
+        const errorMessage =
+          error instanceof Error ? error.message : String(error);
+        expect(errorMessage).toContain(
+          'Streaming setup timeout troubleshooting:',
+        );
+        expect(errorMessage).toContain(
+          'Check network connectivity and firewall settings',
+        );
+        expect(errorMessage).toContain('Consider using non-streaming mode');
+      }
+    });
+  });
+
+  describe('timeout configuration', () => {
+    it('should use default timeout configuration', () => {
+      const contentGeneratorConfig = {
+        model: 'gpt-4',
+        apiKey: 'test-key',
+        authType: AuthType.USE_OPENAI,
+        baseUrl: 'http://localhost:8080',
+      };
+      new OpenAIContentGenerator(contentGeneratorConfig, mockConfig);
+
+      // Verify OpenAI client was created with timeout config
+      expect(OpenAI).toHaveBeenCalledWith({
+        apiKey: 'test-key',
+        baseURL: 'http://localhost:8080',
+        timeout: 120000,
+        maxRetries: 3,
+        defaultHeaders: {
+          'User-Agent': expect.stringMatching(/^QwenCode/),
+        },
+      });
+    });
+
+    it('should use custom timeout from config', () => {
+      const customConfig = {
+        getContentGeneratorConfig: vi.fn().mockReturnValue({}),
+        getCliVersion: vi.fn().mockReturnValue('1.0.0'),
+      } as unknown as Config;
+
+      const contentGeneratorConfig = {
+        model: 'gpt-4',
+        apiKey: 'test-key',
+        baseUrl: 'http://localhost:8080',
+        authType: AuthType.USE_OPENAI,
+        timeout: 300000,
+        maxRetries: 5,
+      };
+      new OpenAIContentGenerator(contentGeneratorConfig, customConfig);
+
+      expect(OpenAI).toHaveBeenCalledWith({
+        apiKey: 'test-key',
+        baseURL: 'http://localhost:8080',
+        timeout: 300000,
+        maxRetries: 5,
+        defaultHeaders: {
+          'User-Agent': expect.stringMatching(/^QwenCode/),
+        },
+      });
+    });
+
+    it('should handle missing timeout config gracefully', () => {
+      const noTimeoutConfig = {
+        getContentGeneratorConfig: vi.fn().mockReturnValue({}),
+        getCliVersion: vi.fn().mockReturnValue('1.0.0'),
+      } as unknown as Config;
+
+      const contentGeneratorConfig = {
+        model: 'gpt-4',
+        apiKey: 'test-key',
+        authType: AuthType.USE_OPENAI,
+        baseUrl: 'http://localhost:8080',
+      };
+      new OpenAIContentGenerator(contentGeneratorConfig, noTimeoutConfig);
+
+      expect(OpenAI).toHaveBeenCalledWith({
+        apiKey: 'test-key',
+        baseURL: 'http://localhost:8080',
+        timeout: 120000, // default
+        maxRetries: 3, // default
+        defaultHeaders: {
+          'User-Agent': expect.stringMatching(/^QwenCode/),
+        },
+      });
+    });
+  });
+
+  describe('token estimation on timeout', () => {
+    it('should surface a clear timeout error when request times out', async () => {
+      const timeoutError = new Error('Request timeout');
+      mockOpenAIClient.chat.completions.create.mockRejectedValue(timeoutError);
+
+      const request = {
+        contents: [{ role: 'user' as const, parts: [{ text: 'Hello world' }] }],
+        model: 'gpt-4',
+      };
+
+      await expect(
+        generator.generateContent(request, 'test-prompt-id'),
+      ).rejects.toThrow(/Request timeout after \d+s/);
+    });
+
+    it('should fall back to character-based estimation if countTokens fails', async () => {
+      const timeoutError = new Error('Request timeout');
+      mockOpenAIClient.chat.completions.create.mockRejectedValue(timeoutError);
+
+      // Mock countTokens to throw error
+      const mockCountTokens = vi.spyOn(generator, 'countTokens');
+      mockCountTokens.mockRejectedValue(new Error('Count tokens failed'));
+
+      const request = {
+        contents: [{ role: 'user' as const, parts: [{ text: 'Hello world' }] }],
+        model: 'gpt-4',
+      };
+
+      // Should not throw due to token counting failure
+      await expect(
+        generator.generateContent(request, 'test-prompt-id'),
+      ).rejects.toThrow(/Request timeout after \d+s/);
+    });
+  });
+});

projects/ui/qwen-code/packages/core/src/core/__tests__/orphanedToolCallsTest.ts

@@ -0,0 +1,125 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Test cases for orphaned tool calls cleanup
+ */
+
+export const createTestMessages = () => [
+  // System message
+  {
+    role: 'system' as const,
+    content: 'You are a helpful assistant.',
+  },
+  // User message
+  {
+    role: 'user' as const,
+    content: 'Please use a tool to help me.',
+  },
+  // Assistant message with tool calls (some will be orphaned)
+  {
+    role: 'assistant' as const,
+    content: 'I will help you with that.',
+    tool_calls: [
+      {
+        id: 'call_1',
+        type: 'function' as const,
+        function: {
+          name: 'search_web',
+          arguments: '{"query": "test"}',
+        },
+      },
+      {
+        id: 'call_2',
+        type: 'function' as const,
+        function: {
+          name: 'calculate',
+          arguments: '{"expression": "2+2"}',
+        },
+      },
+      {
+        id: 'call_3', // This will be orphaned
+        type: 'function' as const,
+        function: {
+          name: 'send_email',
+          arguments: '{"to": "test@example.com"}',
+        },
+      },
+    ],
+  },
+  // Tool response for call_1
+  {
+    role: 'tool' as const,
+    tool_call_id: 'call_1',
+    content: 'Search results: Found relevant information.',
+  },
+  // Tool response for call_2
+  {
+    role: 'tool' as const,
+    tool_call_id: 'call_2',
+    content: 'Calculation result: 4',
+  },
+  // Note: No tool response for call_3 (this creates the orphaned tool call issue)
+
+  // User continues conversation
+  {
+    role: 'user' as const,
+    content: 'Thank you, that was helpful.',
+  },
+];
+
+export const expectedCleanedMessages = () => [
+  // System message (unchanged)
+  {
+    role: 'system' as const,
+    content: 'You are a helpful assistant.',
+  },
+  // User message (unchanged)
+  {
+    role: 'user' as const,
+    content: 'Please use a tool to help me.',
+  },
+  // Assistant message with only valid tool calls
+  {
+    role: 'assistant' as const,
+    content: 'I will help you with that.',
+    tool_calls: [
+      {
+        id: 'call_1',
+        type: 'function' as const,
+        function: {
+          name: 'search_web',
+          arguments: '{"query": "test"}',
+        },
+      },
+      {
+        id: 'call_2',
+        type: 'function' as const,
+        function: {
+          name: 'calculate',
+          arguments: '{"expression": "2+2"}',
+        },
+      },
+      // call_3 removed because it has no response
+    ],
+  },
+  // Tool responses (unchanged because they have corresponding calls)
+  {
+    role: 'tool' as const,
+    tool_call_id: 'call_1',
+    content: 'Search results: Found relevant information.',
+  },
+  {
+    role: 'tool' as const,
+    tool_call_id: 'call_2',
+    content: 'Calculation result: 4',
+  },
+  // User message (unchanged)
+  {
+    role: 'user' as const,
+    content: 'Thank you, that was helpful.',
+  },
+];

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

@@ -0,0 +1,494 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import 'vitest';
+import {
+  vi,
+  describe,
+  it,
+  expect,
+  afterEach,
+  beforeAll,
+  afterAll,
+} from 'vitest';
+import {
+  ClearcutLogger,
+  LogEvent,
+  LogEventEntry,
+  EventNames,
+  TEST_ONLY,
+} from './clearcut-logger.js';
+import { ConfigParameters } from '../../config/config.js';
+import * as userAccount from '../../utils/user_account.js';
+import * as userId from '../../utils/user_id.js';
+import { EventMetadataKey } from './event-metadata-key.js';
+import { makeFakeConfig } from '../../test-utils/config.js';
+import { http, HttpResponse } from 'msw';
+import { server } from '../../mocks/msw.js';
+import { makeChatCompressionEvent } from '../types.js';
+
+interface CustomMatchers<R = unknown> {
+  toHaveMetadataValue: ([key, value]: [EventMetadataKey, string]) => R;
+  toHaveEventName: (name: EventNames) => R;
+}
+
+declare module 'vitest' {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-empty-object-type
+  interface Matchers<T = any> extends CustomMatchers<T> {}
+}
+
+expect.extend({
+  toHaveEventName(received: LogEventEntry[], name: EventNames) {
+    const { isNot } = this;
+    const event = JSON.parse(received[0].source_extension_json) as LogEvent;
+    const pass = event.event_name === (name as unknown as string);
+    return {
+      pass,
+      message: () =>
+        `event name ${event.event_name} does${isNot ? ' not ' : ''} match ${name}}`,
+    };
+  },
+
+  toHaveMetadataValue(
+    received: LogEventEntry[],
+    [key, value]: [EventMetadataKey, string],
+  ) {
+    const { isNot } = this;
+    const event = JSON.parse(received[0].source_extension_json) as LogEvent;
+    const metadata = event['event_metadata'][0];
+    const data = metadata.find((m) => m.gemini_cli_key === key)?.value;
+
+    const pass = data !== undefined && data === value;
+
+    return {
+      pass,
+      message: () =>
+        `event ${received} does${isNot ? ' not' : ''} have ${value}}`,
+    };
+  },
+});
+
+vi.mock('../../utils/user_account');
+vi.mock('../../utils/user_id');
+
+const mockUserAccount = vi.mocked(userAccount);
+const mockUserId = vi.mocked(userId);
+
+// TODO(richieforeman): Consider moving this to test setup globally.
+beforeAll(() => {
+  server.listen({});
+});
+
+afterEach(() => {
+  server.resetHandlers();
+});
+
+afterAll(() => {
+  server.close();
+});
+
+describe('ClearcutLogger', () => {
+  const NEXT_WAIT_MS = 1234;
+  const CLEARCUT_URL = 'https://play.googleapis.com/log';
+  const MOCK_DATE = new Date('2025-01-02T00:00:00.000Z');
+  const EXAMPLE_RESPONSE = `["${NEXT_WAIT_MS}",null,[[["ANDROID_BACKUP",0],["BATTERY_STATS",0],["SMART_SETUP",0],["TRON",0]],-3334737594024971225],[]]`;
+
+  // A helper to get the internal events array for testing
+  const getEvents = (l: ClearcutLogger): LogEventEntry[][] =>
+    l['events'].toArray() as LogEventEntry[][];
+
+  const getEventsSize = (l: ClearcutLogger): number => l['events'].size;
+
+  const requeueFailedEvents = (l: ClearcutLogger, events: LogEventEntry[][]) =>
+    l['requeueFailedEvents'](events);
+
+  afterEach(() => {
+    vi.unstubAllEnvs();
+  });
+
+  function setup({
+    config = {} as Partial<ConfigParameters>,
+    lifetimeGoogleAccounts = 1,
+    cachedGoogleAccount = 'test@google.com',
+    installationId = 'test-installation-id',
+  } = {}) {
+    server.resetHandlers(
+      http.post(CLEARCUT_URL, () => HttpResponse.text(EXAMPLE_RESPONSE)),
+    );
+
+    vi.useFakeTimers();
+    vi.setSystemTime(MOCK_DATE);
+
+    const loggerConfig = makeFakeConfig({
+      ...config,
+    });
+    ClearcutLogger.clearInstance();
+
+    mockUserAccount.getCachedGoogleAccount.mockReturnValue(cachedGoogleAccount);
+    mockUserAccount.getLifetimeGoogleAccounts.mockReturnValue(
+      lifetimeGoogleAccounts,
+    );
+    mockUserId.getInstallationId.mockReturnValue(installationId);
+
+    const logger = ClearcutLogger.getInstance(loggerConfig);
+
+    return { logger, loggerConfig };
+  }
+
+  afterEach(() => {
+    ClearcutLogger.clearInstance();
+    vi.useRealTimers();
+    vi.restoreAllMocks();
+  });
+
+  describe('getInstance', () => {
+    it.each([
+      { usageStatisticsEnabled: false, expectedValue: undefined },
+      {
+        usageStatisticsEnabled: true,
+        expectedValue: expect.any(ClearcutLogger),
+      },
+    ])(
+      'returns an instance if usage statistics are enabled',
+      ({ usageStatisticsEnabled, expectedValue }) => {
+        ClearcutLogger.clearInstance();
+        const { logger } = setup({
+          config: {
+            usageStatisticsEnabled,
+          },
+        });
+        expect(logger).toEqual(expectedValue);
+      },
+    );
+
+    it('is a singleton', () => {
+      ClearcutLogger.clearInstance();
+      const { loggerConfig } = setup();
+      const logger1 = ClearcutLogger.getInstance(loggerConfig);
+      const logger2 = ClearcutLogger.getInstance(loggerConfig);
+      expect(logger1).toBe(logger2);
+    });
+  });
+
+  describe('createLogEvent', () => {
+    it('logs the total number of google accounts', () => {
+      const { logger } = setup({
+        lifetimeGoogleAccounts: 9001,
+      });
+
+      const event = logger?.createLogEvent(EventNames.API_ERROR, []);
+
+      expect(event?.event_metadata[0]).toContainEqual({
+        gemini_cli_key: EventMetadataKey.GEMINI_CLI_GOOGLE_ACCOUNTS_COUNT,
+        value: '9001',
+      });
+    });
+
+    it('logs the current surface from a github action', () => {
+      const { logger } = setup({});
+
+      vi.stubEnv('GITHUB_SHA', '8675309');
+
+      const event = logger?.createLogEvent(EventNames.CHAT_COMPRESSION, []);
+
+      expect(event?.event_metadata[0]).toContainEqual({
+        gemini_cli_key: EventMetadataKey.GEMINI_CLI_SURFACE,
+        value: 'GitHub',
+      });
+    });
+
+    it('logs the current surface', () => {
+      const { logger } = setup({});
+
+      vi.stubEnv('TERM_PROGRAM', 'vscode');
+      vi.stubEnv('SURFACE', 'ide-1234');
+
+      const event = logger?.createLogEvent(EventNames.API_ERROR, []);
+
+      expect(event?.event_metadata[0]).toContainEqual({
+        gemini_cli_key: EventMetadataKey.GEMINI_CLI_SURFACE,
+        value: 'ide-1234',
+      });
+    });
+
+    it.each([
+      {
+        env: {
+          CURSOR_TRACE_ID: 'abc123',
+          GITHUB_SHA: undefined,
+        },
+        expectedValue: 'cursor',
+      },
+      {
+        env: {
+          TERM_PROGRAM: 'vscode',
+          GITHUB_SHA: undefined,
+        },
+        expectedValue: 'vscode',
+      },
+      {
+        env: {
+          MONOSPACE_ENV: 'true',
+          GITHUB_SHA: undefined,
+        },
+        expectedValue: 'firebasestudio',
+      },
+      {
+        env: {
+          __COG_BASHRC_SOURCED: 'true',
+          GITHUB_SHA: undefined,
+        },
+        expectedValue: 'devin',
+      },
+      {
+        env: {
+          CLOUD_SHELL: 'true',
+          GITHUB_SHA: undefined,
+        },
+        expectedValue: 'cloudshell',
+      },
+    ])(
+      'logs the current surface as $expectedValue, preempting vscode detection',
+      ({ env, expectedValue }) => {
+        const { logger } = setup({});
+
+        // Clear all environment variables that could interfere with surface detection
+        vi.stubEnv('SURFACE', undefined);
+        vi.stubEnv('GITHUB_SHA', undefined);
+        vi.stubEnv('CURSOR_TRACE_ID', undefined);
+        vi.stubEnv('__COG_BASHRC_SOURCED', undefined);
+        vi.stubEnv('REPLIT_USER', undefined);
+        vi.stubEnv('CODESPACES', undefined);
+        vi.stubEnv('EDITOR_IN_CLOUD_SHELL', undefined);
+        vi.stubEnv('CLOUD_SHELL', undefined);
+        vi.stubEnv('TERM_PRODUCT', undefined);
+        vi.stubEnv('FIREBASE_DEPLOY_AGENT', undefined);
+        vi.stubEnv('MONOSPACE_ENV', undefined);
+
+        // Set the specific environment variables for this test case
+        for (const [key, value] of Object.entries(env)) {
+          vi.stubEnv(key, value);
+        }
+        vi.stubEnv('TERM_PROGRAM', 'vscode');
+        const event = logger?.createLogEvent(EventNames.API_ERROR, []);
+        expect(event?.event_metadata[0][3]).toEqual({
+          gemini_cli_key: EventMetadataKey.GEMINI_CLI_SURFACE,
+          value: expectedValue,
+        });
+      },
+    );
+  });
+
+  describe('logChatCompressionEvent', () => {
+    it('logs an event with proper fields', () => {
+      const { logger } = setup();
+      logger?.logChatCompressionEvent(
+        makeChatCompressionEvent({
+          tokens_before: 9001,
+          tokens_after: 8000,
+        }),
+      );
+
+      const events = getEvents(logger!);
+      expect(events.length).toBe(1);
+      expect(events[0]).toHaveEventName(EventNames.CHAT_COMPRESSION);
+      expect(events[0]).toHaveMetadataValue([
+        EventMetadataKey.GEMINI_CLI_COMPRESSION_TOKENS_BEFORE,
+        '9001',
+      ]);
+      expect(events[0]).toHaveMetadataValue([
+        EventMetadataKey.GEMINI_CLI_COMPRESSION_TOKENS_AFTER,
+        '8000',
+      ]);
+    });
+  });
+
+  describe('enqueueLogEvent', () => {
+    it('should add events to the queue', () => {
+      const { logger } = setup();
+      logger!.enqueueLogEvent(logger!.createLogEvent(EventNames.API_ERROR));
+      expect(getEventsSize(logger!)).toBe(1);
+    });
+
+    it('should evict the oldest event when the queue is full', () => {
+      const { logger } = setup();
+
+      for (let i = 0; i < TEST_ONLY.MAX_EVENTS; i++) {
+        logger!.enqueueLogEvent(
+          logger!.createLogEvent(EventNames.API_ERROR, [
+            {
+              gemini_cli_key: EventMetadataKey.GEMINI_CLI_AI_ADDED_LINES,
+              value: `${i}`,
+            },
+          ]),
+        );
+      }
+
+      let events = getEvents(logger!);
+      expect(events.length).toBe(TEST_ONLY.MAX_EVENTS);
+      expect(events[0]).toHaveMetadataValue([
+        EventMetadataKey.GEMINI_CLI_AI_ADDED_LINES,
+        '0',
+      ]);
+
+      // This should push out the first event
+      logger!.enqueueLogEvent(
+        logger!.createLogEvent(EventNames.API_ERROR, [
+          {
+            gemini_cli_key: EventMetadataKey.GEMINI_CLI_AI_ADDED_LINES,
+            value: `${TEST_ONLY.MAX_EVENTS}`,
+          },
+        ]),
+      );
+      events = getEvents(logger!);
+      expect(events.length).toBe(TEST_ONLY.MAX_EVENTS);
+      expect(events[0]).toHaveMetadataValue([
+        EventMetadataKey.GEMINI_CLI_AI_ADDED_LINES,
+        '1',
+      ]);
+
+      expect(events.at(TEST_ONLY.MAX_EVENTS - 1)).toHaveMetadataValue([
+        EventMetadataKey.GEMINI_CLI_AI_ADDED_LINES,
+        `${TEST_ONLY.MAX_EVENTS}`,
+      ]);
+    });
+  });
+
+  describe('flushToClearcut', () => {
+    it('allows for usage with a configured proxy agent', async () => {
+      const { logger } = setup({
+        config: {
+          proxy: 'http://mycoolproxy.whatever.com:3128',
+        },
+      });
+
+      logger!.enqueueLogEvent(logger!.createLogEvent(EventNames.API_ERROR));
+
+      const response = await logger!.flushToClearcut();
+
+      expect(response.nextRequestWaitMs).toBe(NEXT_WAIT_MS);
+    });
+
+    it('should clear events on successful flush', async () => {
+      const { logger } = setup();
+
+      logger!.enqueueLogEvent(logger!.createLogEvent(EventNames.API_ERROR));
+      const response = await logger!.flushToClearcut();
+
+      expect(getEvents(logger!)).toEqual([]);
+      expect(response.nextRequestWaitMs).toBe(NEXT_WAIT_MS);
+    });
+
+    it('should handle a network error and requeue events', async () => {
+      const { logger } = setup();
+
+      server.resetHandlers(http.post(CLEARCUT_URL, () => HttpResponse.error()));
+      logger!.enqueueLogEvent(logger!.createLogEvent(EventNames.API_REQUEST));
+      logger!.enqueueLogEvent(logger!.createLogEvent(EventNames.API_ERROR));
+      expect(getEventsSize(logger!)).toBe(2);
+
+      const x = logger!.flushToClearcut();
+      await x;
+
+      expect(getEventsSize(logger!)).toBe(2);
+      const events = getEvents(logger!);
+
+      expect(events.length).toBe(2);
+      expect(events[0]).toHaveEventName(EventNames.API_REQUEST);
+    });
+
+    it('should handle an HTTP error and requeue events', async () => {
+      const { logger } = setup();
+
+      server.resetHandlers(
+        http.post(
+          CLEARCUT_URL,
+          () =>
+            new HttpResponse(
+              { 'the system is down': true },
+              {
+                status: 500,
+              },
+            ),
+        ),
+      );
+
+      logger!.enqueueLogEvent(logger!.createLogEvent(EventNames.API_REQUEST));
+      logger!.enqueueLogEvent(logger!.createLogEvent(EventNames.API_ERROR));
+
+      expect(getEvents(logger!).length).toBe(2);
+      await logger!.flushToClearcut();
+
+      const events = getEvents(logger!);
+
+      expect(events[0]).toHaveEventName(EventNames.API_REQUEST);
+    });
+  });
+
+  describe('requeueFailedEvents logic', () => {
+    it('should limit the number of requeued events to max_retry_events', () => {
+      const { logger } = setup();
+      const eventsToLogCount = TEST_ONLY.MAX_RETRY_EVENTS + 5;
+      const eventsToSend: LogEventEntry[][] = [];
+      for (let i = 0; i < eventsToLogCount; i++) {
+        eventsToSend.push([
+          {
+            event_time_ms: Date.now(),
+            source_extension_json: JSON.stringify({ event_id: i }),
+          },
+        ]);
+      }
+
+      requeueFailedEvents(logger!, eventsToSend);
+
+      expect(getEventsSize(logger!)).toBe(TEST_ONLY.MAX_RETRY_EVENTS);
+      const firstRequeuedEvent = JSON.parse(
+        getEvents(logger!)[0][0].source_extension_json,
+      ) as { event_id: string };
+      // The last `maxRetryEvents` are kept. The oldest of those is at index `eventsToLogCount - maxRetryEvents`.
+      expect(firstRequeuedEvent.event_id).toBe(
+        eventsToLogCount - TEST_ONLY.MAX_RETRY_EVENTS,
+      );
+    });
+
+    it('should not requeue more events than available space in the queue', () => {
+      const { logger } = setup();
+      const maxEvents = TEST_ONLY.MAX_EVENTS;
+      const spaceToLeave = 5;
+      const initialEventCount = maxEvents - spaceToLeave;
+      for (let i = 0; i < initialEventCount; i++) {
+        logger!.enqueueLogEvent(logger!.createLogEvent(EventNames.API_ERROR));
+      }
+      expect(getEventsSize(logger!)).toBe(initialEventCount);
+
+      const failedEventsCount = 10; // More than spaceToLeave
+      const eventsToSend: LogEventEntry[][] = [];
+      for (let i = 0; i < failedEventsCount; i++) {
+        eventsToSend.push([
+          {
+            event_time_ms: Date.now(),
+            source_extension_json: JSON.stringify({ event_id: `failed_${i}` }),
+          },
+        ]);
+      }
+
+      requeueFailedEvents(logger!, eventsToSend);
+
+      // availableSpace is 5. eventsToRequeue is min(10, 5) = 5.
+      // Total size should be initialEventCount + 5 = maxEvents.
+      expect(getEventsSize(logger!)).toBe(maxEvents);
+
+      // The requeued events are the *last* 5 of the failed events.
+      // startIndex = max(0, 10 - 5) = 5.
+      // Loop unshifts events from index 9 down to 5.
+      // The first element in the deque is the one with id 'failed_5'.
+      const firstRequeuedEvent = JSON.parse(
+        getEvents(logger!)[0][0].source_extension_json,
+      ) as { event_id: string };
+      expect(firstRequeuedEvent.event_id).toBe('failed_5');
+    });
+  });
+});

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

@@ -0,0 +1,860 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { HttpsProxyAgent } from 'https-proxy-agent';
+import {
+  StartSessionEvent,
+  UserPromptEvent,
+  ToolCallEvent,
+  ApiRequestEvent,
+  ApiResponseEvent,
+  ApiErrorEvent,
+  LoopDetectedEvent,
+  NextSpeakerCheckEvent,
+  SlashCommandEvent,
+  MalformedJsonResponseEvent,
+  IdeConnectionEvent,
+  KittySequenceOverflowEvent,
+  ChatCompressionEvent,
+  InvalidChunkEvent,
+  ContentRetryEvent,
+  ContentRetryFailureEvent,
+} from '../types.js';
+import { EventMetadataKey } from './event-metadata-key.js';
+import { Config } from '../../config/config.js';
+import { safeJsonStringify } from '../../utils/safeJsonStringify.js';
+import {
+  getCachedGoogleAccount,
+  getLifetimeGoogleAccounts,
+} from '../../utils/user_account.js';
+import { getInstallationId } from '../../utils/user_id.js';
+import { FixedDeque } from 'mnemonist';
+import { GIT_COMMIT_INFO, CLI_VERSION } from '../../generated/git-commit.js';
+import { DetectedIde, detectIde } from '../../ide/detect-ide.js';
+
+export enum EventNames {
+  START_SESSION = 'start_session',
+  NEW_PROMPT = 'new_prompt',
+  TOOL_CALL = 'tool_call',
+  API_REQUEST = 'api_request',
+  API_RESPONSE = 'api_response',
+  API_ERROR = 'api_error',
+  END_SESSION = 'end_session',
+  FLASH_FALLBACK = 'flash_fallback',
+  LOOP_DETECTED = 'loop_detected',
+  NEXT_SPEAKER_CHECK = 'next_speaker_check',
+  SLASH_COMMAND = 'slash_command',
+  MALFORMED_JSON_RESPONSE = 'malformed_json_response',
+  IDE_CONNECTION = 'ide_connection',
+  KITTY_SEQUENCE_OVERFLOW = 'kitty_sequence_overflow',
+  CHAT_COMPRESSION = 'chat_compression',
+  INVALID_CHUNK = 'invalid_chunk',
+  CONTENT_RETRY = 'content_retry',
+  CONTENT_RETRY_FAILURE = 'content_retry_failure',
+}
+
+export interface LogResponse {
+  nextRequestWaitMs?: number;
+}
+
+export interface LogEventEntry {
+  event_time_ms: number;
+  source_extension_json: string;
+}
+
+export interface EventValue {
+  gemini_cli_key: EventMetadataKey;
+  value: string;
+}
+
+export interface LogEvent {
+  console_type: 'GEMINI_CLI';
+  application: number;
+  event_name: string;
+  event_metadata: EventValue[][];
+  client_email?: string;
+  client_install_id?: string;
+}
+
+export interface LogRequest {
+  log_source_name: 'CONCORD';
+  request_time_ms: number;
+  log_event: LogEventEntry[][];
+}
+
+/**
+ * Determine the surface that the user is currently using.  Surface is effectively the
+ * distribution channel in which the user is using Gemini CLI.  Gemini CLI comes bundled
+ * w/ Firebase Studio and Cloud Shell.  Users that manually download themselves will
+ * likely be "SURFACE_NOT_SET".
+ *
+ * This is computed based upon a series of environment variables these distribution
+ * methods might have in their runtimes.
+ */
+function determineSurface(): string {
+  if (process.env['SURFACE']) {
+    return process.env['SURFACE'];
+  } else if (process.env['GITHUB_SHA']) {
+    return 'GitHub';
+  } else if (process.env['TERM_PROGRAM'] === 'vscode') {
+    return detectIde() || DetectedIde.VSCode;
+  } else {
+    return 'SURFACE_NOT_SET';
+  }
+}
+
+/**
+ * Clearcut URL to send logging events to.
+ */
+const CLEARCUT_URL = 'https://play.googleapis.com/log?format=json&hasfast=true';
+
+/**
+ * Interval in which buffered events are sent to clearcut.
+ */
+const FLUSH_INTERVAL_MS = 1000 * 60;
+
+/**
+ * Maximum amount of events to keep in memory. Events added after this amount
+ * are dropped until the next flush to clearcut, which happens periodically as
+ * defined by {@link FLUSH_INTERVAL_MS}.
+ */
+const MAX_EVENTS = 1000;
+
+/**
+ * Maximum events to retry after a failed clearcut flush
+ */
+const MAX_RETRY_EVENTS = 100;
+
+// Singleton class for batch posting log events to Clearcut. When a new event comes in, the elapsed time
+// is checked and events are flushed to Clearcut if at least a minute has passed since the last flush.
+export class ClearcutLogger {
+  private static instance: ClearcutLogger;
+  private config?: Config;
+  private sessionData: EventValue[] = [];
+  private promptId: string = '';
+
+  /**
+   * Queue of pending events that need to be flushed to the server.  New events
+   * are added to this queue and then flushed on demand (via `flushToClearcut`)
+   */
+  private readonly events: FixedDeque<LogEventEntry[]>;
+
+  /**
+   * The last time that the events were successfully flushed to the server.
+   */
+  private lastFlushTime: number = Date.now();
+
+  /**
+   * the value is true when there is a pending flush happening. This prevents
+   * concurrent flush operations.
+   */
+  private flushing: boolean = false;
+
+  /**
+   * This value is true when a flush was requested during an ongoing flush.
+   */
+  private pendingFlush: boolean = false;
+
+  private constructor(config?: Config) {
+    this.config = config;
+    this.events = new FixedDeque<LogEventEntry[]>(Array, MAX_EVENTS);
+    this.promptId = config?.getSessionId() ?? '';
+  }
+
+  static getInstance(config?: Config): ClearcutLogger | undefined {
+    if (config === undefined || !config?.getUsageStatisticsEnabled())
+      return undefined;
+    if (!ClearcutLogger.instance) {
+      ClearcutLogger.instance = new ClearcutLogger(config);
+    }
+    return ClearcutLogger.instance;
+  }
+
+  /** For testing purposes only. */
+  static clearInstance(): void {
+    // @ts-expect-error - ClearcutLogger is a singleton, but we need to clear it for tests.
+    ClearcutLogger.instance = undefined;
+  }
+
+  enqueueLogEvent(event: LogEvent): void {
+    try {
+      // Manually handle overflow for FixedDeque, which throws when full.
+      const wasAtCapacity = this.events.size >= MAX_EVENTS;
+
+      if (wasAtCapacity) {
+        this.events.shift(); // Evict oldest element to make space.
+      }
+
+      this.events.push([
+        {
+          event_time_ms: Date.now(),
+          source_extension_json: safeJsonStringify(event),
+        },
+      ]);
+
+      if (wasAtCapacity && this.config?.getDebugMode()) {
+        console.debug(
+          `ClearcutLogger: Dropped old event to prevent memory leak (queue size: ${this.events.size})`,
+        );
+      }
+    } catch (error) {
+      if (this.config?.getDebugMode()) {
+        console.error('ClearcutLogger: Failed to enqueue log event.', error);
+      }
+    }
+  }
+
+  createLogEvent(eventName: EventNames, data: EventValue[] = []): LogEvent {
+    const email = getCachedGoogleAccount();
+
+    if (eventName !== EventNames.START_SESSION) {
+      data.push(...this.sessionData);
+    }
+    data = this.addDefaultFields(data);
+
+    const logEvent: LogEvent = {
+      console_type: 'GEMINI_CLI',
+      application: 102, // GEMINI_CLI
+      event_name: eventName as string,
+      event_metadata: [data],
+    };
+
+    // Should log either email or install ID, not both. See go/cloudmill-1p-oss-instrumentation#define-sessionable-id
+    if (email) {
+      logEvent.client_email = email;
+    } else {
+      logEvent.client_install_id = getInstallationId();
+    }
+
+    return logEvent;
+  }
+
+  flushIfNeeded(): void {
+    if (Date.now() - this.lastFlushTime < FLUSH_INTERVAL_MS) {
+      return;
+    }
+
+    this.flushToClearcut().catch((error) => {
+      console.debug('Error flushing to Clearcut:', error);
+    });
+  }
+
+  async flushToClearcut(): Promise<LogResponse> {
+    if (this.flushing) {
+      if (this.config?.getDebugMode()) {
+        console.debug(
+          'ClearcutLogger: Flush already in progress, marking pending flush.',
+        );
+      }
+      this.pendingFlush = true;
+      return Promise.resolve({});
+    }
+    this.flushing = true;
+
+    if (this.config?.getDebugMode()) {
+      console.log('Flushing log events to Clearcut.');
+    }
+    const eventsToSend = this.events.toArray() as LogEventEntry[][];
+    this.events.clear();
+
+    const request: LogRequest[] = [
+      {
+        log_source_name: 'CONCORD',
+        request_time_ms: Date.now(),
+        log_event: eventsToSend,
+      },
+    ];
+
+    let result: LogResponse = {};
+
+    try {
+      const response = await fetch(CLEARCUT_URL, {
+        method: 'POST',
+        body: safeJsonStringify(request),
+        headers: {
+          'Content-Type': 'application/json',
+        },
+      });
+
+      const responseBody = await response.text();
+
+      if (response.status >= 200 && response.status < 300) {
+        this.lastFlushTime = Date.now();
+        const nextRequestWaitMs = Number(JSON.parse(responseBody)[0]);
+        result = {
+          ...result,
+          nextRequestWaitMs,
+        };
+      } else {
+        if (this.config?.getDebugMode()) {
+          console.error(
+            `Error flushing log events: HTTP ${response.status}: ${response.statusText}`,
+          );
+        }
+
+        // Re-queue failed events for retry
+        this.requeueFailedEvents(eventsToSend);
+      }
+    } catch (e: unknown) {
+      if (this.config?.getDebugMode()) {
+        console.error('Error flushing log events:', e as Error);
+      }
+
+      // Re-queue failed events for retry
+      this.requeueFailedEvents(eventsToSend);
+    }
+
+    this.flushing = false;
+
+    // If a flush was requested while we were flushing, flush again
+    if (this.pendingFlush) {
+      this.pendingFlush = false;
+      // Fire and forget the pending flush
+      this.flushToClearcut().catch((error) => {
+        if (this.config?.getDebugMode()) {
+          console.debug('Error in pending flush to Clearcut:', error);
+        }
+      });
+    }
+
+    return result;
+  }
+
+  logStartSessionEvent(event: StartSessionEvent): void {
+    const data: EventValue[] = [
+      {
+        gemini_cli_key: EventMetadataKey.GEMINI_CLI_START_SESSION_MODEL,
+        value: event.model,
+      },
+      {
+        gemini_cli_key:
+          EventMetadataKey.GEMINI_CLI_START_SESSION_EMBEDDING_MODEL,
+        value: event.embedding_model,
+      },
+      {
+        gemini_cli_key: EventMetadataKey.GEMINI_CLI_START_SESSION_SANDBOX,
+        value: event.sandbox_enabled.toString(),
+      },
+      {
+        gemini_cli_key: EventMetadataKey.GEMINI_CLI_START_SESSION_CORE_TOOLS,
+        value: event.core_tools_enabled,
+      },
+      {
+        gemini_cli_key: EventMetadataKey.GEMINI_CLI_START_SESSION_APPROVAL_MODE,
+        value: event.approval_mode,
+      },
+      {
+        gemini_cli_key:
+          EventMetadataKey.GEMINI_CLI_START_SESSION_API_KEY_ENABLED,
+        value: event.api_key_enabled.toString(),
+      },
+      {
+        gemini_cli_key:
+          EventMetadataKey.GEMINI_CLI_START_SESSION_VERTEX_API_ENABLED,
+        value: event.vertex_ai_enabled.toString(),
+      },
+      {
+        gemini_cli_key:
+          EventMetadataKey.GEMINI_CLI_START_SESSION_DEBUG_MODE_ENABLED,
+        value: event.debug_enabled.toString(),
+      },
+      {
+        gemini_cli_key:
+          EventMetadataKey.GEMINI_CLI_START_SESSION_VERTEX_API_ENABLED,
+        value: event.vertex_ai_enabled.toString(),
+      },
+      {
+        gemini_cli_key: EventMetadataKey.GEMINI_CLI_START_SESSION_MCP_SERVERS,
+        value: event.mcp_servers,
+      },
+      {
+        gemini_cli_key:
+          EventMetadataKey.GEMINI_CLI_START_SESSION_VERTEX_API_ENABLED,
+        value: event.vertex_ai_enabled.toString(),
+      },
+      {
+        gemini_cli_key:
+          EventMetadataKey.GEMINI_CLI_START_SESSION_TELEMETRY_ENABLED,
+        value: event.telemetry_enabled.toString(),
+      },
+      {
+        gemini_cli_key:
+          EventMetadataKey.GEMINI_CLI_START_SESSION_TELEMETRY_LOG_USER_PROMPTS_ENABLED,
+        value: event.telemetry_log_user_prompts_enabled.toString(),
+      },
+    ];
+    this.sessionData = data;
+
+    // Flush start event immediately
+    this.enqueueLogEvent(this.createLogEvent(EventNames.START_SESSION, data));
+    this.flushToClearcut().catch((error) => {
+      console.debug('Error flushing to Clearcut:', error);
+    });
+  }
+
+  logNewPromptEvent(event: UserPromptEvent): void {
+    this.promptId = event.prompt_id;
+    const data: EventValue[] = [
+      {
+        gemini_cli_key: EventMetadataKey.GEMINI_CLI_USER_PROMPT_LENGTH,
+        value: JSON.stringify(event.prompt_length),
+      },
+    ];
+
+    this.enqueueLogEvent(this.createLogEvent(EventNames.NEW_PROMPT, data));
+    this.flushIfNeeded();
+  }
+
+  logToolCallEvent(event: ToolCallEvent): void {
+    const data: EventValue[] = [
+      {
+        gemini_cli_key: EventMetadataKey.GEMINI_CLI_TOOL_CALL_NAME,
+        value: JSON.stringify(event.function_name),
+      },
+      {
+        gemini_cli_key: EventMetadataKey.GEMINI_CLI_TOOL_CALL_DECISION,
+        value: JSON.stringify(event.decision),
+      },
+      {
+        gemini_cli_key: EventMetadataKey.GEMINI_CLI_TOOL_CALL_SUCCESS,
+        value: JSON.stringify(event.success),
+      },
+      {
+        gemini_cli_key: EventMetadataKey.GEMINI_CLI_TOOL_CALL_DURATION_MS,
+        value: JSON.stringify(event.duration_ms),
+      },
+      {
+        gemini_cli_key: EventMetadataKey.GEMINI_CLI_TOOL_ERROR_MESSAGE,
+        value: JSON.stringify(event.error),
+      },
+      {
+        gemini_cli_key: EventMetadataKey.GEMINI_CLI_TOOL_CALL_ERROR_TYPE,
+        value: JSON.stringify(event.error_type),
+      },
+      {
+        gemini_cli_key: EventMetadataKey.GEMINI_CLI_TOOL_TYPE,
+        value: JSON.stringify(event.tool_type),
+      },
+    ];
+
+    if (event.metadata) {
+      const metadataMapping: { [key: string]: EventMetadataKey } = {
+        ai_added_lines: EventMetadataKey.GEMINI_CLI_AI_ADDED_LINES,
+        ai_removed_lines: EventMetadataKey.GEMINI_CLI_AI_REMOVED_LINES,
+        user_added_lines: EventMetadataKey.GEMINI_CLI_USER_ADDED_LINES,
+        user_removed_lines: EventMetadataKey.GEMINI_CLI_USER_REMOVED_LINES,
+      };
+
+      for (const [key, gemini_cli_key] of Object.entries(metadataMapping)) {
+        if (event.metadata[key] !== undefined) {
+          data.push({
+            gemini_cli_key,
+            value: JSON.stringify(event.metadata[key]),
+          });
+        }
+      }
+    }
+
+    const logEvent = this.createLogEvent(EventNames.TOOL_CALL, data);
+    this.enqueueLogEvent(logEvent);
+    this.flushIfNeeded();
+  }
+
+  logApiRequestEvent(event: ApiRequestEvent): void {
+    const data: EventValue[] = [
+      {
+        gemini_cli_key: EventMetadataKey.GEMINI_CLI_API_REQUEST_MODEL,
+        value: JSON.stringify(event.model),
+      },
+    ];
+
+    this.enqueueLogEvent(this.createLogEvent(EventNames.API_REQUEST, data));
+    this.flushIfNeeded();
+  }
+
+  logApiResponseEvent(event: ApiResponseEvent): void {
+    const data: EventValue[] = [
+      {
+        gemini_cli_key: EventMetadataKey.GEMINI_CLI_API_RESPONSE_MODEL,
+        value: JSON.stringify(event.model),
+      },
+      {
+        gemini_cli_key: EventMetadataKey.GEMINI_CLI_API_RESPONSE_STATUS_CODE,
+        value: JSON.stringify(event.status_code),
+      },
+      {
+        gemini_cli_key: EventMetadataKey.GEMINI_CLI_API_RESPONSE_DURATION_MS,
+        value: JSON.stringify(event.duration_ms),
+      },
+      {
+        gemini_cli_key: EventMetadataKey.GEMINI_CLI_API_ERROR_MESSAGE,
+        value: JSON.stringify(event.error),
+      },
+      {
+        gemini_cli_key:
+          EventMetadataKey.GEMINI_CLI_API_RESPONSE_INPUT_TOKEN_COUNT,
+        value: JSON.stringify(event.input_token_count),
+      },
+      {
+        gemini_cli_key:
+          EventMetadataKey.GEMINI_CLI_API_RESPONSE_OUTPUT_TOKEN_COUNT,
+        value: JSON.stringify(event.output_token_count),
+      },
+      {
+        gemini_cli_key:
+          EventMetadataKey.GEMINI_CLI_API_RESPONSE_CACHED_TOKEN_COUNT,
+        value: JSON.stringify(event.cached_content_token_count),
+      },
+      {
+        gemini_cli_key:
+          EventMetadataKey.GEMINI_CLI_API_RESPONSE_THINKING_TOKEN_COUNT,
+        value: JSON.stringify(event.thoughts_token_count),
+      },
+      {
+        gemini_cli_key:
+          EventMetadataKey.GEMINI_CLI_API_RESPONSE_TOOL_TOKEN_COUNT,
+        value: JSON.stringify(event.tool_token_count),
+      },
+    ];
+
+    this.enqueueLogEvent(this.createLogEvent(EventNames.API_RESPONSE, data));
+    this.flushIfNeeded();
+  }
+
+  logApiErrorEvent(event: ApiErrorEvent): void {
+    const data: EventValue[] = [
+      {
+        gemini_cli_key: EventMetadataKey.GEMINI_CLI_API_ERROR_MODEL,
+        value: JSON.stringify(event.model),
+      },
+      {
+        gemini_cli_key: EventMetadataKey.GEMINI_CLI_API_ERROR_TYPE,
+        value: JSON.stringify(event.error_type),
+      },
+      {
+        gemini_cli_key: EventMetadataKey.GEMINI_CLI_API_ERROR_STATUS_CODE,
+        value: JSON.stringify(event.status_code),
+      },
+      {
+        gemini_cli_key: EventMetadataKey.GEMINI_CLI_API_ERROR_DURATION_MS,
+        value: JSON.stringify(event.duration_ms),
+      },
+    ];
+
+    this.enqueueLogEvent(this.createLogEvent(EventNames.API_ERROR, data));
+    this.flushIfNeeded();
+  }
+
+  logChatCompressionEvent(event: ChatCompressionEvent): void {
+    const data: EventValue[] = [
+      {
+        gemini_cli_key: EventMetadataKey.GEMINI_CLI_COMPRESSION_TOKENS_BEFORE,
+        value: `${event.tokens_before}`,
+      },
+      {
+        gemini_cli_key: EventMetadataKey.GEMINI_CLI_COMPRESSION_TOKENS_AFTER,
+        value: `${event.tokens_after}`,
+      },
+    ];
+
+    this.enqueueLogEvent(
+      this.createLogEvent(EventNames.CHAT_COMPRESSION, data),
+    );
+  }
+
+  logFlashFallbackEvent(): void {
+    this.enqueueLogEvent(this.createLogEvent(EventNames.FLASH_FALLBACK, []));
+    this.flushToClearcut().catch((error) => {
+      console.debug('Error flushing to Clearcut:', error);
+    });
+  }
+
+  logLoopDetectedEvent(event: LoopDetectedEvent): void {
+    const data: EventValue[] = [
+      {
+        gemini_cli_key: EventMetadataKey.GEMINI_CLI_LOOP_DETECTED_TYPE,
+        value: JSON.stringify(event.loop_type),
+      },
+    ];
+
+    this.enqueueLogEvent(this.createLogEvent(EventNames.LOOP_DETECTED, data));
+    this.flushIfNeeded();
+  }
+
+  logNextSpeakerCheck(event: NextSpeakerCheckEvent): void {
+    const data: EventValue[] = [
+      {
+        gemini_cli_key: EventMetadataKey.GEMINI_CLI_RESPONSE_FINISH_REASON,
+        value: JSON.stringify(event.finish_reason),
+      },
+      {
+        gemini_cli_key: EventMetadataKey.GEMINI_CLI_NEXT_SPEAKER_CHECK_RESULT,
+        value: JSON.stringify(event.result),
+      },
+    ];
+
+    this.enqueueLogEvent(
+      this.createLogEvent(EventNames.NEXT_SPEAKER_CHECK, data),
+    );
+    this.flushIfNeeded();
+  }
+
+  logSlashCommandEvent(event: SlashCommandEvent): void {
+    const data: EventValue[] = [
+      {
+        gemini_cli_key: EventMetadataKey.GEMINI_CLI_SLASH_COMMAND_NAME,
+        value: JSON.stringify(event.command),
+      },
+    ];
+
+    if (event.subcommand) {
+      data.push({
+        gemini_cli_key: EventMetadataKey.GEMINI_CLI_SLASH_COMMAND_SUBCOMMAND,
+        value: JSON.stringify(event.subcommand),
+      });
+    }
+
+    if (event.status) {
+      data.push({
+        gemini_cli_key: EventMetadataKey.GEMINI_CLI_SLASH_COMMAND_STATUS,
+        value: JSON.stringify(event.status),
+      });
+    }
+
+    this.enqueueLogEvent(this.createLogEvent(EventNames.SLASH_COMMAND, data));
+    this.flushIfNeeded();
+  }
+
+  logMalformedJsonResponseEvent(event: MalformedJsonResponseEvent): void {
+    const data: EventValue[] = [
+      {
+        gemini_cli_key:
+          EventMetadataKey.GEMINI_CLI_MALFORMED_JSON_RESPONSE_MODEL,
+        value: JSON.stringify(event.model),
+      },
+    ];
+
+    this.enqueueLogEvent(
+      this.createLogEvent(EventNames.MALFORMED_JSON_RESPONSE, data),
+    );
+    this.flushIfNeeded();
+  }
+
+  logIdeConnectionEvent(event: IdeConnectionEvent): void {
+    const data: EventValue[] = [
+      {
+        gemini_cli_key: EventMetadataKey.GEMINI_CLI_IDE_CONNECTION_TYPE,
+        value: JSON.stringify(event.connection_type),
+      },
+    ];
+
+    this.enqueueLogEvent(this.createLogEvent(EventNames.IDE_CONNECTION, data));
+    this.flushIfNeeded();
+  }
+
+  logKittySequenceOverflowEvent(event: KittySequenceOverflowEvent): void {
+    const data: EventValue[] = [
+      {
+        gemini_cli_key: EventMetadataKey.GEMINI_CLI_KITTY_SEQUENCE_LENGTH,
+        value: event.sequence_length.toString(),
+      },
+      {
+        gemini_cli_key: EventMetadataKey.GEMINI_CLI_KITTY_TRUNCATED_SEQUENCE,
+        value: event.truncated_sequence,
+      },
+    ];
+
+    this.enqueueLogEvent(
+      this.createLogEvent(EventNames.KITTY_SEQUENCE_OVERFLOW, data),
+    );
+    this.flushIfNeeded();
+  }
+
+  logEndSessionEvent(): void {
+    // Flush immediately on session end.
+    this.enqueueLogEvent(this.createLogEvent(EventNames.END_SESSION, []));
+    this.flushToClearcut().catch((error) => {
+      console.debug('Error flushing to Clearcut:', error);
+    });
+  }
+
+  logInvalidChunkEvent(event: InvalidChunkEvent): void {
+    const data: EventValue[] = [];
+
+    if (event.error_message) {
+      data.push({
+        gemini_cli_key: EventMetadataKey.GEMINI_CLI_INVALID_CHUNK_ERROR_MESSAGE,
+        value: event.error_message,
+      });
+    }
+
+    this.enqueueLogEvent(this.createLogEvent(EventNames.INVALID_CHUNK, data));
+    this.flushIfNeeded();
+  }
+
+  logContentRetryEvent(event: ContentRetryEvent): void {
+    const data: EventValue[] = [
+      {
+        gemini_cli_key:
+          EventMetadataKey.GEMINI_CLI_CONTENT_RETRY_ATTEMPT_NUMBER,
+        value: String(event.attempt_number),
+      },
+      {
+        gemini_cli_key: EventMetadataKey.GEMINI_CLI_CONTENT_RETRY_ERROR_TYPE,
+        value: event.error_type,
+      },
+      {
+        gemini_cli_key: EventMetadataKey.GEMINI_CLI_CONTENT_RETRY_DELAY_MS,
+        value: String(event.retry_delay_ms),
+      },
+    ];
+
+    this.enqueueLogEvent(this.createLogEvent(EventNames.CONTENT_RETRY, data));
+    this.flushIfNeeded();
+  }
+
+  logContentRetryFailureEvent(event: ContentRetryFailureEvent): void {
+    const data: EventValue[] = [
+      {
+        gemini_cli_key:
+          EventMetadataKey.GEMINI_CLI_CONTENT_RETRY_FAILURE_TOTAL_ATTEMPTS,
+        value: String(event.total_attempts),
+      },
+      {
+        gemini_cli_key:
+          EventMetadataKey.GEMINI_CLI_CONTENT_RETRY_FAILURE_FINAL_ERROR_TYPE,
+        value: event.final_error_type,
+      },
+    ];
+
+    if (event.total_duration_ms) {
+      data.push({
+        gemini_cli_key:
+          EventMetadataKey.GEMINI_CLI_CONTENT_RETRY_FAILURE_TOTAL_DURATION_MS,
+        value: String(event.total_duration_ms),
+      });
+    }
+
+    this.enqueueLogEvent(
+      this.createLogEvent(EventNames.CONTENT_RETRY_FAILURE, data),
+    );
+    this.flushIfNeeded();
+  }
+
+  /**
+   * Adds default fields to data, and returns a new data array.  This fields
+   * should exist on all log events.
+   */
+  addDefaultFields(data: EventValue[]): EventValue[] {
+    const totalAccounts = getLifetimeGoogleAccounts();
+    const surface = determineSurface();
+
+    const defaultLogMetadata: EventValue[] = [
+      {
+        gemini_cli_key: EventMetadataKey.GEMINI_CLI_SESSION_ID,
+        value: this.config?.getSessionId() ?? '',
+      },
+      {
+        gemini_cli_key: EventMetadataKey.GEMINI_CLI_AUTH_TYPE,
+        value: JSON.stringify(
+          this.config?.getContentGeneratorConfig()?.authType,
+        ),
+      },
+      {
+        gemini_cli_key: EventMetadataKey.GEMINI_CLI_GOOGLE_ACCOUNTS_COUNT,
+        value: `${totalAccounts}`,
+      },
+      {
+        gemini_cli_key: EventMetadataKey.GEMINI_CLI_SURFACE,
+        value: surface,
+      },
+      {
+        gemini_cli_key: EventMetadataKey.GEMINI_CLI_VERSION,
+        value: CLI_VERSION,
+      },
+      {
+        gemini_cli_key: EventMetadataKey.GEMINI_CLI_GIT_COMMIT_HASH,
+        value: GIT_COMMIT_INFO,
+      },
+      {
+        gemini_cli_key: EventMetadataKey.GEMINI_CLI_PROMPT_ID,
+        value: this.promptId,
+      },
+    ];
+    return [...data, ...defaultLogMetadata];
+  }
+
+  getProxyAgent() {
+    const proxyUrl = this.config?.getProxy();
+    if (!proxyUrl) return undefined;
+    // undici which is widely used in the repo can only support http & https proxy protocol,
+    // https://github.com/nodejs/undici/issues/2224
+    if (proxyUrl.startsWith('http')) {
+      return new HttpsProxyAgent(proxyUrl);
+    } else {
+      throw new Error('Unsupported proxy type');
+    }
+  }
+
+  shutdown() {
+    this.logEndSessionEvent();
+  }
+
+  private requeueFailedEvents(eventsToSend: LogEventEntry[][]): void {
+    // Add the events back to the front of the queue to be retried, but limit retry queue size
+    const eventsToRetry = eventsToSend.slice(-MAX_RETRY_EVENTS); // Keep only the most recent events
+
+    // Log a warning if we're dropping events
+    if (eventsToSend.length > MAX_RETRY_EVENTS && this.config?.getDebugMode()) {
+      console.warn(
+        `ClearcutLogger: Dropping ${
+          eventsToSend.length - MAX_RETRY_EVENTS
+        } events due to retry queue limit. Total events: ${
+          eventsToSend.length
+        }, keeping: ${MAX_RETRY_EVENTS}`,
+      );
+    }
+
+    // Determine how many events can be re-queued
+    const availableSpace = MAX_EVENTS - this.events.size;
+    const numEventsToRequeue = Math.min(eventsToRetry.length, availableSpace);
+
+    if (numEventsToRequeue === 0) {
+      if (this.config?.getDebugMode()) {
+        console.debug(
+          `ClearcutLogger: No events re-queued (queue size: ${this.events.size})`,
+        );
+      }
+      return;
+    }
+
+    // Get the most recent events to re-queue
+    const eventsToRequeue = eventsToRetry.slice(
+      eventsToRetry.length - numEventsToRequeue,
+    );
+
+    // Prepend events to the front of the deque to be retried first.
+    // We iterate backwards to maintain the original order of the failed events.
+    for (let i = eventsToRequeue.length - 1; i >= 0; i--) {
+      this.events.unshift(eventsToRequeue[i]);
+    }
+    // Clear any potential overflow
+    while (this.events.size > MAX_EVENTS) {
+      this.events.pop();
+    }
+
+    if (this.config?.getDebugMode()) {
+      console.debug(
+        `ClearcutLogger: Re-queued ${numEventsToRequeue} events for retry (queue size: ${this.events.size})`,
+      );
+    }
+  }
+}
+
+export const TEST_ONLY = {
+  MAX_RETRY_EVENTS,
+  MAX_EVENTS,
+};

projects/ui/qwen-code/packages/core/src/telemetry/clearcut-logger/event-metadata-key.ts

@@ -0,0 +1,318 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+// Defines valid event metadata keys for Qwen logging.
+export enum EventMetadataKey {
+  GEMINI_CLI_KEY_UNKNOWN = 0,
+
+  // ==========================================================================
+  // Start Session Event Keys
+  // ===========================================================================
+
+  // Logs the model id used in the session.
+  GEMINI_CLI_START_SESSION_MODEL = 1,
+
+  // Logs the embedding model id used in the session.
+  GEMINI_CLI_START_SESSION_EMBEDDING_MODEL = 2,
+
+  // Logs the sandbox that was used in the session.
+  GEMINI_CLI_START_SESSION_SANDBOX = 3,
+
+  // Logs the core tools that were enabled in the session.
+  GEMINI_CLI_START_SESSION_CORE_TOOLS = 4,
+
+  // Logs the approval mode that was used in the session.
+  GEMINI_CLI_START_SESSION_APPROVAL_MODE = 5,
+
+  // Logs whether an API key was used in the session.
+  GEMINI_CLI_START_SESSION_API_KEY_ENABLED = 6,
+
+  // Logs whether the Vertex API was used in the session.
+  GEMINI_CLI_START_SESSION_VERTEX_API_ENABLED = 7,
+
+  // Logs whether debug mode was enabled in the session.
+  GEMINI_CLI_START_SESSION_DEBUG_MODE_ENABLED = 8,
+
+  // Logs the MCP servers that were enabled in the session.
+  GEMINI_CLI_START_SESSION_MCP_SERVERS = 9,
+
+  // Logs whether user-collected telemetry was enabled in the session.
+  GEMINI_CLI_START_SESSION_TELEMETRY_ENABLED = 10,
+
+  // Logs whether prompt collection was enabled for user-collected telemetry.
+  GEMINI_CLI_START_SESSION_TELEMETRY_LOG_USER_PROMPTS_ENABLED = 11,
+
+  // Logs whether the session was configured to respect gitignore files.
+  GEMINI_CLI_START_SESSION_RESPECT_GITIGNORE = 12,
+
+  // ==========================================================================
+  // User Prompt Event Keys
+  // ===========================================================================
+
+  // Logs the length of the prompt.
+  GEMINI_CLI_USER_PROMPT_LENGTH = 13,
+
+  // ==========================================================================
+  // Tool Call Event Keys
+  // ===========================================================================
+
+  // Logs the function name.
+  GEMINI_CLI_TOOL_CALL_NAME = 14,
+
+  // Logs the user's decision about how to handle the tool call.
+  GEMINI_CLI_TOOL_CALL_DECISION = 15,
+
+  // Logs whether the tool call succeeded.
+  GEMINI_CLI_TOOL_CALL_SUCCESS = 16,
+
+  // Logs the tool call duration in milliseconds.
+  GEMINI_CLI_TOOL_CALL_DURATION_MS = 17,
+
+  // Logs the tool call error message, if any.
+  GEMINI_CLI_TOOL_ERROR_MESSAGE = 18,
+
+  // Logs the tool call error type, if any.
+  GEMINI_CLI_TOOL_CALL_ERROR_TYPE = 19,
+
+  // ==========================================================================
+  // GenAI API Request Event Keys
+  // ===========================================================================
+
+  // Logs the model id of the request.
+  GEMINI_CLI_API_REQUEST_MODEL = 20,
+
+  // ==========================================================================
+  // GenAI API Response Event Keys
+  // ===========================================================================
+
+  // Logs the model id of the API call.
+  GEMINI_CLI_API_RESPONSE_MODEL = 21,
+
+  // Logs the status code of the response.
+  GEMINI_CLI_API_RESPONSE_STATUS_CODE = 22,
+
+  // Logs the duration of the API call in milliseconds.
+  GEMINI_CLI_API_RESPONSE_DURATION_MS = 23,
+
+  // Logs the error message of the API call, if any.
+  GEMINI_CLI_API_ERROR_MESSAGE = 24,
+
+  // Logs the input token count of the API call.
+  GEMINI_CLI_API_RESPONSE_INPUT_TOKEN_COUNT = 25,
+
+  // Logs the output token count of the API call.
+  GEMINI_CLI_API_RESPONSE_OUTPUT_TOKEN_COUNT = 26,
+
+  // Logs the cached token count of the API call.
+  GEMINI_CLI_API_RESPONSE_CACHED_TOKEN_COUNT = 27,
+
+  // Logs the thinking token count of the API call.
+  GEMINI_CLI_API_RESPONSE_THINKING_TOKEN_COUNT = 28,
+
+  // Logs the tool use token count of the API call.
+  GEMINI_CLI_API_RESPONSE_TOOL_TOKEN_COUNT = 29,
+
+  // ==========================================================================
+  // GenAI API Error Event Keys
+  // ===========================================================================
+
+  // Logs the model id of the API call.
+  GEMINI_CLI_API_ERROR_MODEL = 30,
+
+  // Logs the error type.
+  GEMINI_CLI_API_ERROR_TYPE = 31,
+
+  // Logs the status code of the error response.
+  GEMINI_CLI_API_ERROR_STATUS_CODE = 32,
+
+  // Logs the duration of the API call in milliseconds.
+  GEMINI_CLI_API_ERROR_DURATION_MS = 33,
+
+  // ==========================================================================
+  // End Session Event Keys
+  // ===========================================================================
+
+  // Logs the end of a session.
+  GEMINI_CLI_END_SESSION_ID = 34,
+
+  // ==========================================================================
+  // Shared Keys
+  // ===========================================================================
+
+  // Logs the Prompt Id
+  GEMINI_CLI_PROMPT_ID = 35,
+
+  // Logs the Auth type for the prompt, api responses and errors.
+  GEMINI_CLI_AUTH_TYPE = 36,
+
+  // Logs the total number of Google accounts ever used.
+  GEMINI_CLI_GOOGLE_ACCOUNTS_COUNT = 37,
+
+  // Logs the Surface from where the Gemini CLI was invoked, eg: VSCode.
+  GEMINI_CLI_SURFACE = 39,
+
+  // Logs the session id
+  GEMINI_CLI_SESSION_ID = 40,
+
+  // Logs the Gemini CLI version
+  GEMINI_CLI_VERSION = 54,
+
+  // Logs the Gemini CLI Git commit hash
+  GEMINI_CLI_GIT_COMMIT_HASH = 55,
+
+  // ==========================================================================
+  // Loop Detected Event Keys
+  // ===========================================================================
+
+  // Logs the type of loop detected.
+  GEMINI_CLI_LOOP_DETECTED_TYPE = 38,
+
+  // ==========================================================================
+  // Slash Command Event Keys
+  // ===========================================================================
+
+  // Logs the name of the slash command.
+  GEMINI_CLI_SLASH_COMMAND_NAME = 41,
+
+  // Logs the subcommand of the slash command.
+  GEMINI_CLI_SLASH_COMMAND_SUBCOMMAND = 42,
+
+  // Logs the status of the slash command (e.g. 'success', 'error')
+  GEMINI_CLI_SLASH_COMMAND_STATUS = 51,
+
+  // ==========================================================================
+  // Next Speaker Check Event Keys
+  // ===========================================================================
+
+  // Logs the finish reason of the previous streamGenerateContent response
+  GEMINI_CLI_RESPONSE_FINISH_REASON = 43,
+
+  // Logs the result of the next speaker check
+  GEMINI_CLI_NEXT_SPEAKER_CHECK_RESULT = 44,
+
+  // ==========================================================================
+  // Malformed JSON Response Event Keys
+  // ==========================================================================
+
+  // Logs the model that produced the malformed JSON response.
+  GEMINI_CLI_MALFORMED_JSON_RESPONSE_MODEL = 45,
+
+  // ==========================================================================
+  // IDE Connection Event Keys
+  // ===========================================================================
+
+  // Logs the type of the IDE connection.
+  GEMINI_CLI_IDE_CONNECTION_TYPE = 46,
+
+  // Logs AI added lines in edit/write tool response.
+  GEMINI_CLI_AI_ADDED_LINES = 47,
+
+  // Logs AI removed lines in edit/write tool response.
+  GEMINI_CLI_AI_REMOVED_LINES = 48,
+
+  // Logs user added lines in edit/write tool response.
+  GEMINI_CLI_USER_ADDED_LINES = 49,
+
+  // Logs user removed lines in edit/write tool response.
+  GEMINI_CLI_USER_REMOVED_LINES = 50,
+
+  // ==========================================================================
+  // Kitty Sequence Overflow Event Keys
+  // ===========================================================================
+
+  // Logs the truncated kitty sequence.
+  GEMINI_CLI_KITTY_TRUNCATED_SEQUENCE = 52,
+
+  // Logs the length of the kitty sequence that overflowed.
+  GEMINI_CLI_KITTY_SEQUENCE_LENGTH = 53,
+
+  // ==========================================================================
+  // Conversation Finished Event Keys
+  // ===========================================================================
+
+  // Logs the approval mode of the session.
+  GEMINI_CLI_APPROVAL_MODE = 58,
+
+  // Logs the number of turns
+  GEMINI_CLI_CONVERSATION_TURN_COUNT = 59,
+
+  // Logs the number of tokens before context window compression.
+  GEMINI_CLI_COMPRESSION_TOKENS_BEFORE = 60,
+
+  // Logs the number of tokens after context window compression.
+  GEMINI_CLI_COMPRESSION_TOKENS_AFTER = 61,
+
+  // Logs tool type whether it is mcp or native.
+  GEMINI_CLI_TOOL_TYPE = 62,
+  // Logs name of MCP tools as comma separated string
+  GEMINI_CLI_START_SESSION_MCP_TOOLS = 65,
+
+  // ==========================================================================
+  // Research Event Keys
+  // ===========================================================================
+
+  // Logs the research opt-in status (true/false)
+  GEMINI_CLI_RESEARCH_OPT_IN_STATUS = 66,
+
+  // Logs the contact email for research participation
+  GEMINI_CLI_RESEARCH_CONTACT_EMAIL = 67,
+
+  // Logs the user ID for research events
+  GEMINI_CLI_RESEARCH_USER_ID = 68,
+
+  // Logs the type of research feedback
+  GEMINI_CLI_RESEARCH_FEEDBACK_TYPE = 69,
+
+  // Logs the content of research feedback
+  GEMINI_CLI_RESEARCH_FEEDBACK_CONTENT = 70,
+
+  // Logs survey responses for research feedback (JSON stringified)
+  GEMINI_CLI_RESEARCH_SURVEY_RESPONSES = 71,
+
+  // ==========================================================================
+  // File Operation Event Keys
+  // ===========================================================================
+
+  // Logs the programming language of the project.
+  GEMINI_CLI_PROGRAMMING_LANGUAGE = 56,
+
+  // Logs the operation type of the file operation.
+  GEMINI_CLI_FILE_OPERATION_TYPE = 57,
+
+  // Logs the number of lines in the file operation.
+  GEMINI_CLI_FILE_OPERATION_LINES = 72,
+
+  // Logs the mimetype of the file in the file operation.
+  GEMINI_CLI_FILE_OPERATION_MIMETYPE = 73,
+
+  // Logs the extension of the file in the file operation.
+  GEMINI_CLI_FILE_OPERATION_EXTENSION = 74,
+
+  // ==========================================================================
+  // Content Streaming Event Keys
+  // ===========================================================================
+
+  // Logs the error message for an invalid chunk.
+  GEMINI_CLI_INVALID_CHUNK_ERROR_MESSAGE = 75,
+
+  // Logs the attempt number for a content retry.
+  GEMINI_CLI_CONTENT_RETRY_ATTEMPT_NUMBER = 76,
+
+  // Logs the error type for a content retry.
+  GEMINI_CLI_CONTENT_RETRY_ERROR_TYPE = 77,
+
+  // Logs the delay in milliseconds for a content retry.
+  GEMINI_CLI_CONTENT_RETRY_DELAY_MS = 78,
+
+  // Logs the total number of attempts for a content retry failure.
+  GEMINI_CLI_CONTENT_RETRY_FAILURE_TOTAL_ATTEMPTS = 79,
+
+  // Logs the final error type for a content retry failure.
+  GEMINI_CLI_CONTENT_RETRY_FAILURE_FINAL_ERROR_TYPE = 80,
+
+  // Logs the total duration in milliseconds for a content retry failure.
+  GEMINI_CLI_CONTENT_RETRY_FAILURE_TOTAL_DURATION_MS = 81,
+}

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

@@ -0,0 +1,84 @@
+// RUM Protocol Data Structures
+export interface RumApp {
+  id: string;
+  env: string;
+  version: string;
+  type: 'cli' | 'extension';
+}
+
+export interface RumUser {
+  id: string;
+}
+
+export interface RumSession {
+  id: string;
+}
+
+export interface RumView {
+  id: string;
+  name: string;
+}
+
+export interface RumEvent {
+  timestamp?: number;
+  event_type?: 'view' | 'action' | 'exception' | 'resource';
+  type: string; // Event type
+  name: string; // Event name
+  snapshots?: string; // JSON string of event snapshots
+  properties?: Record<string, unknown>;
+  // [key: string]: unknown;
+}
+
+export interface RumViewEvent extends RumEvent {
+  view_type?: string; // View rendering type
+  time_spent?: number; // Time spent on current view in ms
+}
+
+export interface RumActionEvent extends RumEvent {
+  target_name?: string; // Element user interacted with (for auto-collected actions only)
+  duration?: number; // Action duration in ms
+  method_info?: string; // Action callback, e.g.: onClick()
+}
+
+export interface RumExceptionEvent extends RumEvent {
+  source?: string; // Error source, e.g.: console, event
+  file?: string; // Error file
+  subtype?: string; // Secondary classification of error type
+  message?: string; // Concise, readable message explaining the event
+  stack?: string; // Stack trace or supplemental information about the error
+  caused_by?: string; // Exception cause
+  line?: number; // Line number where exception occurred
+  column?: number; // Column number where exception occurred
+  thread_id?: string; // Thread ID
+  binary_images?: string; // Error source
+}
+
+export interface RumResourceEvent extends RumEvent {
+  method?: string; // HTTP request method: POST, GET, etc.
+  status_code?: string; // Resource status code
+  message?: string; // Error message content, corresponds to resource.error_msg
+  url?: string; // Resource URL
+  provider_type?: string; // Resource provider type: first-party, cdn, ad, analytics
+  trace_id?: string; // Resource request TraceID
+  success?: number; // Resource loading success: 1 (default) success, 0 failure
+  duration?: number; // Total time spent loading resource in ms (responseEnd - redirectStart)
+  size?: number; // Resource size in bytes, corresponds to decodedBodySize
+  connect_duration?: number; // Time spent establishing connection to server in ms (connectEnd - connectStart)
+  ssl_duration?: number; // Time spent on TLS handshake in ms (connectEnd - secureConnectionStart), 0 if no SSL
+  dns_duration?: number; // Time spent resolving DNS name in ms (domainLookupEnd - domainLookupStart)
+  redirect_duration?: number; // Time spent on HTTP redirects in ms (redirectEnd - redirectStart)
+  first_byte_duration?: number; // Time waiting for first byte of response in ms (responseStart - requestStart)
+  download_duration?: number; // Time spent downloading response in ms (responseEnd - responseStart)
+  timing_data?: string; // JSON string of PerformanceResourceTiming
+  trace_data?: string; // Trace information snapshot JSON string
+}
+
+export interface RumPayload {
+  app: RumApp;
+  user: RumUser;
+  session: RumSession;
+  view: RumView;
+  events: RumEvent[];
+  properties?: Record<string, unknown>;
+  _v: string;
+}

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

@@ -0,0 +1,407 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import {
+  describe,
+  it,
+  expect,
+  vi,
+  beforeEach,
+  afterEach,
+  afterAll,
+} from 'vitest';
+import { QwenLogger, TEST_ONLY } from './qwen-logger.js';
+import { Config } from '../../config/config.js';
+import {
+  StartSessionEvent,
+  EndSessionEvent,
+  IdeConnectionEvent,
+  KittySequenceOverflowEvent,
+  IdeConnectionType,
+} from '../types.js';
+import { RumEvent } from './event-types.js';
+
+// Mock dependencies
+vi.mock('../../utils/user_id.js', () => ({
+  getInstallationId: vi.fn(() => 'test-installation-id'),
+}));
+
+vi.mock('../../utils/safeJsonStringify.js', () => ({
+  safeJsonStringify: vi.fn((obj) => JSON.stringify(obj)),
+}));
+
+// Mock https module
+vi.mock('https', () => ({
+  request: vi.fn(),
+}));
+
+const makeFakeConfig = (overrides: Partial<Config> = {}): Config => {
+  const defaults = {
+    getUsageStatisticsEnabled: () => true,
+    getDebugMode: () => false,
+    getSessionId: () => 'test-session-id',
+    getCliVersion: () => '1.0.0',
+    getProxy: () => undefined,
+    getContentGeneratorConfig: () => ({ authType: 'test-auth' }),
+    getMcpServers: () => ({}),
+    getModel: () => 'test-model',
+    getEmbeddingModel: () => 'test-embedding',
+    getSandbox: () => false,
+    getCoreTools: () => [],
+    getApprovalMode: () => 'auto',
+    getTelemetryEnabled: () => true,
+    getTelemetryLogPromptsEnabled: () => false,
+    getFileFilteringRespectGitIgnore: () => true,
+    ...overrides,
+  };
+  return defaults as Config;
+};
+
+describe('QwenLogger', () => {
+  let mockConfig: Config;
+
+  beforeEach(() => {
+    vi.useFakeTimers();
+    vi.setSystemTime(new Date('2025-01-01T12:00:00.000Z'));
+    mockConfig = makeFakeConfig();
+    // Clear singleton instance
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    (QwenLogger as any).instance = undefined;
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+    vi.restoreAllMocks();
+  });
+
+  afterAll(() => {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    (QwenLogger as any).instance = undefined;
+  });
+
+  describe('getInstance', () => {
+    it('returns undefined when usage statistics are disabled', () => {
+      const config = makeFakeConfig({ getUsageStatisticsEnabled: () => false });
+      const logger = QwenLogger.getInstance(config);
+      expect(logger).toBeUndefined();
+    });
+
+    it('returns an instance when usage statistics are enabled', () => {
+      const logger = QwenLogger.getInstance(mockConfig);
+      expect(logger).toBeInstanceOf(QwenLogger);
+    });
+
+    it('is a singleton', () => {
+      const logger1 = QwenLogger.getInstance(mockConfig);
+      const logger2 = QwenLogger.getInstance(mockConfig);
+      expect(logger1).toBe(logger2);
+    });
+  });
+
+  describe('event queue management', () => {
+    it('should handle event overflow gracefully', () => {
+      const debugConfig = makeFakeConfig({ getDebugMode: () => true });
+      const logger = QwenLogger.getInstance(debugConfig)!;
+      const consoleSpy = vi
+        .spyOn(console, 'debug')
+        .mockImplementation(() => {});
+
+      // Fill the queue beyond capacity
+      for (let i = 0; i < TEST_ONLY.MAX_EVENTS + 10; i++) {
+        logger.enqueueLogEvent({
+          timestamp: Date.now(),
+          event_type: 'action',
+          type: 'test',
+          name: `test-event-${i}`,
+        });
+      }
+
+      // Should have logged debug messages about dropping events
+      expect(consoleSpy).toHaveBeenCalledWith(
+        expect.stringContaining(
+          'QwenLogger: Dropped old event to prevent memory leak',
+        ),
+      );
+    });
+
+    it('should handle enqueue errors gracefully', () => {
+      const debugConfig = makeFakeConfig({ getDebugMode: () => true });
+      const logger = QwenLogger.getInstance(debugConfig)!;
+      const consoleSpy = vi
+        .spyOn(console, 'error')
+        .mockImplementation(() => {});
+
+      // Mock the events deque to throw an error
+      const originalPush = logger['events'].push;
+      logger['events'].push = vi.fn(() => {
+        throw new Error('Test error');
+      });
+
+      logger.enqueueLogEvent({
+        timestamp: Date.now(),
+        event_type: 'action',
+        type: 'test',
+        name: 'test-event',
+      });
+
+      expect(consoleSpy).toHaveBeenCalledWith(
+        'QwenLogger: Failed to enqueue log event.',
+        expect.any(Error),
+      );
+
+      // Restore original method
+      logger['events'].push = originalPush;
+    });
+  });
+
+  describe('concurrent flush protection', () => {
+    it('should handle concurrent flush requests', () => {
+      const debugConfig = makeFakeConfig({ getDebugMode: () => true });
+      const logger = QwenLogger.getInstance(debugConfig)!;
+      const consoleSpy = vi
+        .spyOn(console, 'debug')
+        .mockImplementation(() => {});
+
+      // Manually set the flush in progress flag to simulate concurrent access
+      logger['isFlushInProgress'] = true;
+
+      // Try to flush while another flush is in progress
+      const result = logger.flushToRum();
+
+      // Should have logged about pending flush
+      expect(consoleSpy).toHaveBeenCalledWith(
+        expect.stringContaining(
+          'QwenLogger: Flush already in progress, marking pending flush',
+        ),
+      );
+
+      // Should return a resolved promise
+      expect(result).toBeInstanceOf(Promise);
+
+      // Reset the flag
+      logger['isFlushInProgress'] = false;
+    });
+  });
+
+  describe('failed event retry mechanism', () => {
+    it('should requeue failed events with size limits', () => {
+      const debugConfig = makeFakeConfig({ getDebugMode: () => true });
+      const logger = QwenLogger.getInstance(debugConfig)!;
+      const consoleSpy = vi
+        .spyOn(console, 'debug')
+        .mockImplementation(() => {});
+
+      const failedEvents: RumEvent[] = [];
+      for (let i = 0; i < TEST_ONLY.MAX_RETRY_EVENTS + 50; i++) {
+        failedEvents.push({
+          timestamp: Date.now(),
+          event_type: 'action',
+          type: 'test',
+          name: `failed-event-${i}`,
+        });
+      }
+
+      // Call the private method using bracket notation
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      (logger as any).requeueFailedEvents(failedEvents);
+
+      // Should have logged about dropping events due to retry limit
+      expect(consoleSpy).toHaveBeenCalledWith(
+        expect.stringContaining('QwenLogger: Re-queued'),
+      );
+    });
+
+    it('should handle empty retry queue gracefully', () => {
+      const debugConfig = makeFakeConfig({ getDebugMode: () => true });
+      const logger = QwenLogger.getInstance(debugConfig)!;
+      const consoleSpy = vi
+        .spyOn(console, 'debug')
+        .mockImplementation(() => {});
+
+      // Fill the queue to capacity first
+      for (let i = 0; i < TEST_ONLY.MAX_EVENTS; i++) {
+        logger.enqueueLogEvent({
+          timestamp: Date.now(),
+          event_type: 'action',
+          type: 'test',
+          name: `event-${i}`,
+        });
+      }
+
+      // Try to requeue when no space is available
+      const failedEvents: RumEvent[] = [
+        {
+          timestamp: Date.now(),
+          event_type: 'action',
+          type: 'test',
+          name: 'failed-event',
+        },
+      ];
+
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      (logger as any).requeueFailedEvents(failedEvents);
+
+      expect(consoleSpy).toHaveBeenCalledWith(
+        expect.stringContaining('QwenLogger: No events re-queued'),
+      );
+    });
+  });
+
+  describe('event handlers', () => {
+    it('should log IDE connection events', () => {
+      const logger = QwenLogger.getInstance(mockConfig)!;
+      const enqueueSpy = vi.spyOn(logger, 'enqueueLogEvent');
+
+      const event = new IdeConnectionEvent(IdeConnectionType.SESSION);
+
+      logger.logIdeConnectionEvent(event);
+
+      expect(enqueueSpy).toHaveBeenCalledWith(
+        expect.objectContaining({
+          event_type: 'action',
+          type: 'connection',
+          name: 'ide_connection',
+          snapshots: JSON.stringify({
+            connection_type: IdeConnectionType.SESSION,
+          }),
+        }),
+      );
+    });
+
+    it('should log Kitty sequence overflow events', () => {
+      const logger = QwenLogger.getInstance(mockConfig)!;
+      const enqueueSpy = vi.spyOn(logger, 'enqueueLogEvent');
+
+      const event = new KittySequenceOverflowEvent(1024, 'truncated...');
+
+      logger.logKittySequenceOverflowEvent(event);
+
+      expect(enqueueSpy).toHaveBeenCalledWith(
+        expect.objectContaining({
+          event_type: 'exception',
+          type: 'overflow',
+          name: 'kitty_sequence_overflow',
+          subtype: 'kitty_sequence_overflow',
+          snapshots: JSON.stringify({
+            sequence_length: 1024,
+            truncated_sequence: 'truncated...',
+          }),
+        }),
+      );
+    });
+
+    it('should flush start session events immediately', async () => {
+      const logger = QwenLogger.getInstance(mockConfig)!;
+      const flushSpy = vi.spyOn(logger, 'flushToRum').mockResolvedValue({});
+
+      const testConfig = makeFakeConfig({
+        getModel: () => 'test-model',
+        getEmbeddingModel: () => 'test-embedding',
+      });
+      const event = new StartSessionEvent(testConfig);
+
+      logger.logStartSessionEvent(event);
+
+      expect(flushSpy).toHaveBeenCalled();
+    });
+
+    it('should flush end session events immediately', async () => {
+      const logger = QwenLogger.getInstance(mockConfig)!;
+      const flushSpy = vi.spyOn(logger, 'flushToRum').mockResolvedValue({});
+
+      const event = new EndSessionEvent(mockConfig);
+
+      logger.logEndSessionEvent(event);
+
+      expect(flushSpy).toHaveBeenCalled();
+    });
+  });
+
+  describe('flush timing', () => {
+    it('should not flush if interval has not passed', () => {
+      const logger = QwenLogger.getInstance(mockConfig)!;
+      const flushSpy = vi.spyOn(logger, 'flushToRum');
+
+      // Add an event and try to flush immediately
+      logger.enqueueLogEvent({
+        timestamp: Date.now(),
+        event_type: 'action',
+        type: 'test',
+        name: 'test-event',
+      });
+
+      logger.flushIfNeeded();
+
+      expect(flushSpy).not.toHaveBeenCalled();
+    });
+
+    it('should flush when interval has passed', () => {
+      const logger = QwenLogger.getInstance(mockConfig)!;
+      const flushSpy = vi.spyOn(logger, 'flushToRum').mockResolvedValue({});
+
+      // Add an event
+      logger.enqueueLogEvent({
+        timestamp: Date.now(),
+        event_type: 'action',
+        type: 'test',
+        name: 'test-event',
+      });
+
+      // Advance time beyond flush interval
+      vi.advanceTimersByTime(TEST_ONLY.FLUSH_INTERVAL_MS + 1000);
+
+      logger.flushIfNeeded();
+
+      expect(flushSpy).toHaveBeenCalled();
+    });
+  });
+
+  describe('error handling', () => {
+    it('should handle flush errors gracefully with debug mode', async () => {
+      const debugConfig = makeFakeConfig({ getDebugMode: () => true });
+      const logger = QwenLogger.getInstance(debugConfig)!;
+      const consoleSpy = vi
+        .spyOn(console, 'debug')
+        .mockImplementation(() => {});
+
+      // Add an event first
+      logger.enqueueLogEvent({
+        timestamp: Date.now(),
+        event_type: 'action',
+        type: 'test',
+        name: 'test-event',
+      });
+
+      // Mock flushToRum to throw an error
+      const originalFlush = logger.flushToRum.bind(logger);
+      logger.flushToRum = vi.fn().mockRejectedValue(new Error('Network error'));
+
+      // Advance time to trigger flush
+      vi.advanceTimersByTime(TEST_ONLY.FLUSH_INTERVAL_MS + 1000);
+
+      logger.flushIfNeeded();
+
+      // Wait for async operations
+      await vi.runAllTimersAsync();
+
+      expect(consoleSpy).toHaveBeenCalledWith(
+        'Error flushing to RUM:',
+        expect.any(Error),
+      );
+
+      // Restore original method
+      logger.flushToRum = originalFlush;
+    });
+  });
+
+  describe('constants export', () => {
+    it('should export test constants', () => {
+      expect(TEST_ONLY.MAX_EVENTS).toBe(1000);
+      expect(TEST_ONLY.MAX_RETRY_EVENTS).toBe(100);
+      expect(TEST_ONLY.FLUSH_INTERVAL_MS).toBe(60000);
+    });
+  });
+});

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

@@ -0,0 +1,718 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { Buffer } from 'buffer';
+import * as https from 'https';
+import { HttpsProxyAgent } from 'https-proxy-agent';
+
+import {
+  StartSessionEvent,
+  EndSessionEvent,
+  UserPromptEvent,
+  ToolCallEvent,
+  ApiRequestEvent,
+  ApiResponseEvent,
+  ApiErrorEvent,
+  FlashFallbackEvent,
+  LoopDetectedEvent,
+  NextSpeakerCheckEvent,
+  SlashCommandEvent,
+  MalformedJsonResponseEvent,
+  IdeConnectionEvent,
+  KittySequenceOverflowEvent,
+  ChatCompressionEvent,
+  InvalidChunkEvent,
+  ContentRetryEvent,
+  ContentRetryFailureEvent,
+} from '../types.js';
+import {
+  RumEvent,
+  RumViewEvent,
+  RumActionEvent,
+  RumResourceEvent,
+  RumExceptionEvent,
+  RumPayload,
+} from './event-types.js';
+import { Config } from '../../config/config.js';
+import { safeJsonStringify } from '../../utils/safeJsonStringify.js';
+import { HttpError, retryWithBackoff } from '../../utils/retry.js';
+import { getInstallationId } from '../../utils/user_id.js';
+import { FixedDeque } from 'mnemonist';
+import { AuthType } from '../../core/contentGenerator.js';
+
+// Usage statistics collection endpoint
+const USAGE_STATS_HOSTNAME = 'gb4w8c3ygj-default-sea.rum.aliyuncs.com';
+const USAGE_STATS_PATH = '/';
+
+const RUN_APP_ID = 'gb4w8c3ygj@851d5d500f08f92';
+
+/**
+ * Interval in which buffered events are sent to RUM.
+ */
+const FLUSH_INTERVAL_MS = 1000 * 60;
+
+/**
+ * Maximum amount of events to keep in memory. Events added after this amount
+ * are dropped until the next flush to RUM, which happens periodically as
+ * defined by {@link FLUSH_INTERVAL_MS}.
+ */
+const MAX_EVENTS = 1000;
+
+/**
+ * Maximum events to retry after a failed RUM flush
+ */
+const MAX_RETRY_EVENTS = 100;
+
+export interface LogResponse {
+  nextRequestWaitMs?: number;
+}
+
+// Singleton class for batch posting log events to RUM. When a new event comes in, the elapsed time
+// is checked and events are flushed to RUM if at least a minute has passed since the last flush.
+export class QwenLogger {
+  private static instance: QwenLogger;
+  private config?: Config;
+
+  /**
+   * Queue of pending events that need to be flushed to the server. New events
+   * are added to this queue and then flushed on demand (via `flushToRum`)
+   */
+  private readonly events: FixedDeque<RumEvent>;
+
+  /**
+   * The last time that the events were successfully flushed to the server.
+   */
+  private lastFlushTime: number = Date.now();
+
+  private userId: string;
+  private sessionId: string;
+
+  /**
+   * The value is true when there is a pending flush happening. This prevents
+   * concurrent flush operations.
+   */
+  private isFlushInProgress: boolean = false;
+
+  /**
+   * This value is true when a flush was requested during an ongoing flush.
+   */
+  private pendingFlush: boolean = false;
+
+  private isShutdown: boolean = false;
+
+  private constructor(config?: Config) {
+    this.config = config;
+    this.events = new FixedDeque<RumEvent>(Array, MAX_EVENTS);
+    this.userId = this.generateUserId();
+    this.sessionId =
+      typeof this.config?.getSessionId === 'function'
+        ? this.config.getSessionId()
+        : '';
+  }
+
+  private generateUserId(): string {
+    // Use installation ID as user ID for consistency
+    return `user-${getInstallationId()}`;
+  }
+
+  static getInstance(config?: Config): QwenLogger | undefined {
+    if (config === undefined || !config?.getUsageStatisticsEnabled())
+      return undefined;
+    if (!QwenLogger.instance) {
+      QwenLogger.instance = new QwenLogger(config);
+      process.on(
+        'exit',
+        QwenLogger.instance.shutdown.bind(QwenLogger.instance),
+      );
+    }
+
+    return QwenLogger.instance;
+  }
+
+  enqueueLogEvent(event: RumEvent): void {
+    try {
+      // Manually handle overflow for FixedDeque, which throws when full.
+      const wasAtCapacity = this.events.size >= MAX_EVENTS;
+
+      if (wasAtCapacity) {
+        this.events.shift(); // Evict oldest element to make space.
+      }
+
+      this.events.push(event);
+
+      if (wasAtCapacity && this.config?.getDebugMode()) {
+        console.debug(
+          `QwenLogger: Dropped old event to prevent memory leak (queue size: ${this.events.size})`,
+        );
+      }
+    } catch (error) {
+      if (this.config?.getDebugMode()) {
+        console.error('QwenLogger: Failed to enqueue log event.', error);
+      }
+    }
+  }
+
+  createRumEvent(
+    eventType: 'view' | 'action' | 'exception' | 'resource',
+    type: string,
+    name: string,
+    properties: Partial<RumEvent>,
+  ): RumEvent {
+    return {
+      timestamp: Date.now(),
+      event_type: eventType,
+      type,
+      name,
+      ...(properties || {}),
+    };
+  }
+
+  createViewEvent(
+    type: string,
+    name: string,
+    properties: Partial<RumViewEvent>,
+  ): RumEvent {
+    return this.createRumEvent('view', type, name, properties);
+  }
+
+  createActionEvent(
+    type: string,
+    name: string,
+    properties: Partial<RumActionEvent>,
+  ): RumEvent {
+    return this.createRumEvent('action', type, name, properties);
+  }
+
+  createResourceEvent(
+    type: string,
+    name: string,
+    properties: Partial<RumResourceEvent>,
+  ): RumEvent {
+    return this.createRumEvent('resource', type, name, properties);
+  }
+
+  createExceptionEvent(
+    type: string,
+    name: string,
+    properties: Partial<RumExceptionEvent>,
+  ): RumEvent {
+    return this.createRumEvent('exception', type, name, properties);
+  }
+
+  async createRumPayload(): Promise<RumPayload> {
+    const authType = this.config?.getAuthType();
+    const version = this.config?.getCliVersion() || 'unknown';
+
+    return {
+      app: {
+        id: RUN_APP_ID,
+        env: process.env['DEBUG'] ? 'dev' : 'prod',
+        version: version || 'unknown',
+        type: 'cli',
+      },
+      user: {
+        id: this.userId,
+      },
+      session: {
+        id: this.sessionId,
+      },
+      view: {
+        id: this.sessionId,
+        name: 'qwen-code-cli',
+      },
+
+      events: this.events.toArray() as RumEvent[],
+      properties: {
+        auth_type: authType,
+        model: this.config?.getModel(),
+        base_url:
+          authType === AuthType.USE_OPENAI
+            ? process.env['OPENAI_BASE_URL']
+            : '',
+      },
+      _v: `qwen-code@${version}`,
+    };
+  }
+
+  flushIfNeeded(): void {
+    if (Date.now() - this.lastFlushTime < FLUSH_INTERVAL_MS) {
+      return;
+    }
+
+    this.flushToRum().catch((error) => {
+      if (this.config?.getDebugMode()) {
+        console.debug('Error flushing to RUM:', error);
+      }
+    });
+  }
+
+  async flushToRum(): Promise<LogResponse> {
+    if (this.isFlushInProgress) {
+      if (this.config?.getDebugMode()) {
+        console.debug(
+          'QwenLogger: Flush already in progress, marking pending flush.',
+        );
+      }
+      this.pendingFlush = true;
+      return Promise.resolve({});
+    }
+    this.isFlushInProgress = true;
+
+    if (this.config?.getDebugMode()) {
+      console.log('Flushing log events to RUM.');
+    }
+    if (this.events.size === 0) {
+      this.isFlushInProgress = false;
+      return {};
+    }
+
+    const eventsToSend = this.events.toArray() as RumEvent[];
+    this.events.clear();
+
+    const rumPayload = await this.createRumPayload();
+    // Override events with the ones we're sending
+    rumPayload.events = eventsToSend;
+    const flushFn = () =>
+      new Promise<Buffer>((resolve, reject) => {
+        const body = safeJsonStringify(rumPayload);
+        const options = {
+          hostname: USAGE_STATS_HOSTNAME,
+          path: USAGE_STATS_PATH,
+          method: 'POST',
+          headers: {
+            'Content-Length': Buffer.byteLength(body),
+            'Content-Type': 'text/plain;charset=UTF-8',
+          },
+        };
+        const bufs: Buffer[] = [];
+        const req = https.request(
+          {
+            ...options,
+            agent: this.getProxyAgent(),
+          },
+          (res) => {
+            if (
+              res.statusCode &&
+              (res.statusCode < 200 || res.statusCode >= 300)
+            ) {
+              const err: HttpError = new Error(
+                `Request failed with status ${res.statusCode}`,
+              );
+              err.status = res.statusCode;
+              res.resume();
+              return reject(err);
+            }
+            res.on('data', (buf) => bufs.push(buf));
+            res.on('end', () => resolve(Buffer.concat(bufs)));
+          },
+        );
+        req.on('error', reject);
+        req.end(body);
+      });
+
+    try {
+      await retryWithBackoff(flushFn, {
+        maxAttempts: 3,
+        initialDelayMs: 200,
+        shouldRetry: (err: unknown) => {
+          if (!(err instanceof Error)) return false;
+          const status = (err as HttpError).status as number | undefined;
+          // If status is not available, it's likely a network error
+          if (status === undefined) return true;
+
+          // Retry on 429 (Too many Requests) and 5xx server errors.
+          return status === 429 || (status >= 500 && status < 600);
+        },
+      });
+
+      this.lastFlushTime = Date.now();
+      return {};
+    } catch (error) {
+      if (this.config?.getDebugMode()) {
+        console.error('RUM flush failed after multiple retries.', error);
+      }
+
+      // Re-queue failed events for retry
+      this.requeueFailedEvents(eventsToSend);
+      return {};
+    } finally {
+      this.isFlushInProgress = false;
+
+      // If a flush was requested while we were flushing, flush again
+      if (this.pendingFlush) {
+        this.pendingFlush = false;
+        // Fire and forget the pending flush
+        this.flushToRum().catch((error) => {
+          if (this.config?.getDebugMode()) {
+            console.debug('Error in pending flush to RUM:', error);
+          }
+        });
+      }
+    }
+  }
+
+  logStartSessionEvent(event: StartSessionEvent): void {
+    const applicationEvent = this.createViewEvent('session', 'session_start', {
+      properties: {
+        model: event.model,
+      },
+      snapshots: JSON.stringify({
+        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,
+        debug_enabled: event.debug_enabled,
+        mcp_servers: event.mcp_servers,
+        telemetry_enabled: event.telemetry_enabled,
+        telemetry_log_user_prompts_enabled:
+          event.telemetry_log_user_prompts_enabled,
+      }),
+    });
+
+    // Flush start event immediately
+    this.enqueueLogEvent(applicationEvent);
+    this.flushToRum().catch((error: unknown) => {
+      if (this.config?.getDebugMode()) {
+        console.debug('Error flushing to RUM:', error);
+      }
+    });
+  }
+
+  logNewPromptEvent(event: UserPromptEvent): void {
+    const rumEvent = this.createActionEvent('user_prompt', 'user_prompt', {
+      properties: {
+        auth_type: event.auth_type,
+        prompt_id: event.prompt_id,
+      },
+      snapshots: JSON.stringify({
+        prompt_length: event.prompt_length,
+      }),
+    });
+
+    this.enqueueLogEvent(rumEvent);
+    this.flushIfNeeded();
+  }
+
+  logToolCallEvent(event: ToolCallEvent): void {
+    const rumEvent = this.createActionEvent(
+      'tool_call',
+      `tool_call#${event.function_name}`,
+      {
+        properties: {
+          prompt_id: event.prompt_id,
+        },
+        snapshots: JSON.stringify({
+          function_name: event.function_name,
+          decision: event.decision,
+          success: event.success,
+          duration_ms: event.duration_ms,
+          error: event.error,
+          error_type: event.error_type,
+        }),
+      },
+    );
+
+    this.enqueueLogEvent(rumEvent);
+    this.flushIfNeeded();
+  }
+
+  logApiRequestEvent(event: ApiRequestEvent): void {
+    const rumEvent = this.createResourceEvent('api', 'api_request', {
+      properties: {
+        model: event.model,
+        prompt_id: event.prompt_id,
+      },
+    });
+
+    this.enqueueLogEvent(rumEvent);
+    this.flushIfNeeded();
+  }
+
+  logApiResponseEvent(event: ApiResponseEvent): void {
+    const rumEvent = this.createResourceEvent('api', 'api_response', {
+      status_code: event.status_code?.toString() ?? '',
+      duration: event.duration_ms,
+      success: 1,
+      message: event.error,
+      trace_id: event.response_id,
+      properties: {
+        auth_type: event.auth_type,
+        model: event.model,
+        prompt_id: event.prompt_id,
+      },
+      snapshots: JSON.stringify({
+        input_token_count: event.input_token_count,
+        output_token_count: event.output_token_count,
+        cached_content_token_count: event.cached_content_token_count,
+        thoughts_token_count: event.thoughts_token_count,
+        tool_token_count: event.tool_token_count,
+      }),
+    });
+
+    this.enqueueLogEvent(rumEvent);
+    this.flushIfNeeded();
+  }
+
+  logApiErrorEvent(event: ApiErrorEvent): void {
+    const rumEvent = this.createResourceEvent('api', 'api_error', {
+      status_code: event.status_code?.toString() ?? '',
+      duration: event.duration_ms,
+      success: 0,
+      message: event.error,
+      trace_id: event.response_id,
+      properties: {
+        auth_type: event.auth_type,
+        model: event.model,
+        prompt_id: event.prompt_id,
+      },
+      snapshots: JSON.stringify({
+        error_type: event.error_type,
+      }),
+    });
+
+    this.enqueueLogEvent(rumEvent);
+    this.flushIfNeeded();
+  }
+
+  logFlashFallbackEvent(event: FlashFallbackEvent): void {
+    const rumEvent = this.createActionEvent('fallback', 'flash_fallback', {
+      properties: {
+        auth_type: event.auth_type,
+      },
+    });
+
+    this.enqueueLogEvent(rumEvent);
+    this.flushIfNeeded();
+  }
+
+  logLoopDetectedEvent(event: LoopDetectedEvent): void {
+    const rumEvent = this.createExceptionEvent('error', 'loop_detected', {
+      subtype: 'loop_detected',
+      properties: {
+        prompt_id: event.prompt_id,
+      },
+      snapshots: JSON.stringify({
+        loop_type: event.loop_type,
+      }),
+    });
+
+    this.enqueueLogEvent(rumEvent);
+    this.flushIfNeeded();
+  }
+
+  logNextSpeakerCheck(event: NextSpeakerCheckEvent): void {
+    const rumEvent = this.createActionEvent('check', 'next_speaker_check', {
+      properties: {
+        prompt_id: event.prompt_id,
+      },
+      snapshots: JSON.stringify({
+        finish_reason: event.finish_reason,
+        result: event.result,
+      }),
+    });
+
+    this.enqueueLogEvent(rumEvent);
+    this.flushIfNeeded();
+  }
+
+  logSlashCommandEvent(event: SlashCommandEvent): void {
+    const rumEvent = this.createActionEvent('command', 'slash_command', {
+      snapshots: JSON.stringify({
+        command: event.command,
+        subcommand: event.subcommand,
+      }),
+    });
+
+    this.enqueueLogEvent(rumEvent);
+    this.flushIfNeeded();
+  }
+
+  logMalformedJsonResponseEvent(event: MalformedJsonResponseEvent): void {
+    const rumEvent = this.createExceptionEvent(
+      'error',
+      'malformed_json_response',
+      {
+        subtype: 'malformed_json_response',
+        properties: {
+          model: event.model,
+        },
+      },
+    );
+
+    this.enqueueLogEvent(rumEvent);
+    this.flushIfNeeded();
+  }
+
+  logIdeConnectionEvent(event: IdeConnectionEvent): void {
+    const rumEvent = this.createActionEvent('connection', 'ide_connection', {
+      snapshots: JSON.stringify({ connection_type: event.connection_type }),
+    });
+
+    this.enqueueLogEvent(rumEvent);
+    this.flushIfNeeded();
+  }
+
+  logKittySequenceOverflowEvent(event: KittySequenceOverflowEvent): void {
+    const rumEvent = this.createExceptionEvent(
+      'overflow',
+      'kitty_sequence_overflow',
+      {
+        subtype: 'kitty_sequence_overflow',
+        snapshots: JSON.stringify({
+          sequence_length: event.sequence_length,
+          truncated_sequence: event.truncated_sequence,
+        }),
+      },
+    );
+
+    this.enqueueLogEvent(rumEvent);
+    this.flushIfNeeded();
+  }
+
+  logChatCompressionEvent(event: ChatCompressionEvent): void {
+    const rumEvent = this.createActionEvent('compression', 'chat_compression', {
+      snapshots: JSON.stringify({
+        tokens_before: event.tokens_before,
+        tokens_after: event.tokens_after,
+      }),
+    });
+
+    this.enqueueLogEvent(rumEvent);
+    this.flushIfNeeded();
+  }
+
+  logInvalidChunkEvent(event: InvalidChunkEvent): void {
+    const rumEvent = this.createExceptionEvent('error', 'invalid_chunk', {
+      subtype: 'invalid_chunk',
+      message: event.error_message,
+    });
+
+    this.enqueueLogEvent(rumEvent);
+    this.flushIfNeeded();
+  }
+
+  logContentRetryEvent(event: ContentRetryEvent): void {
+    const rumEvent = this.createActionEvent('retry', 'content_retry', {
+      snapshots: JSON.stringify({
+        attempt_number: event.attempt_number,
+        error_type: event.error_type,
+        retry_delay_ms: event.retry_delay_ms,
+      }),
+    });
+
+    this.enqueueLogEvent(rumEvent);
+    this.flushIfNeeded();
+  }
+
+  logContentRetryFailureEvent(event: ContentRetryFailureEvent): void {
+    const rumEvent = this.createExceptionEvent(
+      'error',
+      'content_retry_failure',
+      {
+        subtype: 'content_retry_failure',
+        message: `Content retry failed after ${event.total_attempts} attempts`,
+        snapshots: JSON.stringify({
+          total_attempts: event.total_attempts,
+          final_error_type: event.final_error_type,
+          total_duration_ms: event.total_duration_ms,
+        }),
+      },
+    );
+
+    this.enqueueLogEvent(rumEvent);
+    this.flushIfNeeded();
+  }
+
+  logEndSessionEvent(_event: EndSessionEvent): void {
+    const applicationEvent = this.createViewEvent('session', 'session_end', {});
+
+    // Flush immediately on session end.
+    this.enqueueLogEvent(applicationEvent);
+    this.flushToRum().catch((error: unknown) => {
+      if (this.config?.getDebugMode()) {
+        console.debug('Error flushing to RUM:', error);
+      }
+    });
+  }
+
+  getProxyAgent() {
+    const proxyUrl = this.config?.getProxy();
+    if (!proxyUrl) return undefined;
+    // undici which is widely used in the repo can only support http & https proxy protocol,
+    // https://github.com/nodejs/undici/issues/2224
+    if (proxyUrl.startsWith('http')) {
+      return new HttpsProxyAgent(proxyUrl);
+    } else {
+      throw new Error('Unsupported proxy type');
+    }
+  }
+
+  shutdown() {
+    if (this.isShutdown) return;
+
+    this.isShutdown = true;
+    const event = new EndSessionEvent(this.config);
+    this.logEndSessionEvent(event);
+  }
+
+  private requeueFailedEvents(eventsToSend: RumEvent[]): void {
+    // Add the events back to the front of the queue to be retried, but limit retry queue size
+    const eventsToRetry = eventsToSend.slice(-MAX_RETRY_EVENTS); // Keep only the most recent events
+
+    // Log a warning if we're dropping events
+    if (eventsToSend.length > MAX_RETRY_EVENTS && this.config?.getDebugMode()) {
+      console.warn(
+        `QwenLogger: Dropping ${
+          eventsToSend.length - MAX_RETRY_EVENTS
+        } events due to retry queue limit. Total events: ${
+          eventsToSend.length
+        }, keeping: ${MAX_RETRY_EVENTS}`,
+      );
+    }
+
+    // Determine how many events can be re-queued
+    const availableSpace = MAX_EVENTS - this.events.size;
+    const numEventsToRequeue = Math.min(eventsToRetry.length, availableSpace);
+
+    if (numEventsToRequeue === 0) {
+      if (this.config?.getDebugMode()) {
+        console.debug(
+          `QwenLogger: No events re-queued (queue size: ${this.events.size})`,
+        );
+      }
+      return;
+    }
+
+    // Get the most recent events to re-queue
+    const eventsToRequeue = eventsToRetry.slice(
+      eventsToRetry.length - numEventsToRequeue,
+    );
+
+    // Prepend events to the front of the deque to be retried first.
+    // We iterate backwards to maintain the original order of the failed events.
+    for (let i = eventsToRequeue.length - 1; i >= 0; i--) {
+      this.events.unshift(eventsToRequeue[i]);
+    }
+    // Clear any potential overflow
+    while (this.events.size > MAX_EVENTS) {
+      this.events.pop();
+    }
+
+    if (this.config?.getDebugMode()) {
+      console.debug(
+        `QwenLogger: Re-queued ${numEventsToRequeue} events for retry (queue size: ${this.events.size})`,
+      );
+    }
+  }
+}
+
+export const TEST_ONLY = {
+  MAX_RETRY_EVENTS,
+  MAX_EVENTS,
+  FLUSH_INTERVAL_MS,
+};

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

@@ -0,0 +1,73 @@
+// Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
+
+exports[`ShellTool > getDescription > should return the non-windows description when not on windows 1`] = `
+"
+    This tool executes a given shell command as \`bash -c <command>\`. 
+
+      **Background vs Foreground Execution:**
+      You should decide whether commands should run in background or foreground based on their nature:
+      
+      **Use background execution (is_background: true) for:**
+      - Long-running development servers: \`npm run start\`, \`npm run dev\`, \`yarn dev\`, \`bun run start\`
+      - Build watchers: \`npm run watch\`, \`webpack --watch\`
+      - Database servers: \`mongod\`, \`mysql\`, \`redis-server\`
+      - Web servers: \`python -m http.server\`, \`php -S localhost:8000\`
+      - Any command expected to run indefinitely until manually stopped
+      
+      **Use foreground execution (is_background: false) for:**
+      - One-time commands: \`ls\`, \`cat\`, \`grep\`
+      - Build commands: \`npm run build\`, \`make\`
+      - Installation commands: \`npm install\`, \`pip install\`
+      - Git operations: \`git commit\`, \`git push\`
+      - Test runs: \`npm test\`, \`pytest\`
+      
+      Command is executed as a subprocess that leads its own process group. Command process group can be terminated as \`kill -- -PGID\` or signaled as \`kill -s SIGNAL -- -PGID\`.
+
+      The following information is returned:
+
+      Command: Executed command.
+      Directory: Directory (relative to project root) where command was executed, or \`(root)\`.
+      Stdout: Output on stdout stream. Can be \`(empty)\` or partial on error and for any unwaited background processes.
+      Stderr: Output on stderr stream. Can be \`(empty)\` or partial on error and for any unwaited background processes.
+      Error: Error or \`(none)\` if no error was reported for the subprocess.
+      Exit Code: Exit code or \`(none)\` if terminated by signal.
+      Signal: Signal number or \`(none)\` if no signal was received.
+      Background PIDs: List of background processes started or \`(none)\`.
+      Process Group PGID: Process group started or \`(none)\`"
+`;
+
+exports[`ShellTool > getDescription > should return the windows description when on windows 1`] = `
+"
+    This tool executes a given shell command as \`cmd.exe /c <command>\`.
+
+      **Background vs Foreground Execution:**
+      You should decide whether commands should run in background or foreground based on their nature:
+      
+      **Use background execution (is_background: true) for:**
+      - Long-running development servers: \`npm run start\`, \`npm run dev\`, \`yarn dev\`, \`bun run start\`
+      - Build watchers: \`npm run watch\`, \`webpack --watch\`
+      - Database servers: \`mongod\`, \`mysql\`, \`redis-server\`
+      - Web servers: \`python -m http.server\`, \`php -S localhost:8000\`
+      - Any command expected to run indefinitely until manually stopped
+      
+      **Use foreground execution (is_background: false) for:**
+      - One-time commands: \`ls\`, \`cat\`, \`grep\`
+      - Build commands: \`npm run build\`, \`make\`
+      - Installation commands: \`npm install\`, \`pip install\`
+      - Git operations: \`git commit\`, \`git push\`
+      - Test runs: \`npm test\`, \`pytest\`
+      
+      
+
+      The following information is returned:
+
+      Command: Executed command.
+      Directory: Directory (relative to project root) where command was executed, or \`(root)\`.
+      Stdout: Output on stdout stream. Can be \`(empty)\` or partial on error and for any unwaited background processes.
+      Stderr: Output on stderr stream. Can be \`(empty)\` or partial on error and for any unwaited background processes.
+      Error: Error or \`(none)\` if no error was reported for the subprocess.
+      Exit Code: Exit code or \`(none)\` if terminated by signal.
+      Signal: Signal number or \`(none)\` if no signal was received.
+      Background PIDs: List of background processes started or \`(none)\`.
+      Process Group PGID: Process group started or \`(none)\`"
+`;

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

@@ -0,0 +1,123 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { describe, it, expect, vi, afterEach, beforeEach } from 'vitest';
+import { getCacheKey, read, write, clear } from './crawlCache.js';
+
+describe('CrawlCache', () => {
+  describe('getCacheKey', () => {
+    it('should generate a consistent hash', () => {
+      const key1 = getCacheKey('/foo', 'bar');
+      const key2 = getCacheKey('/foo', 'bar');
+      expect(key1).toBe(key2);
+    });
+
+    it('should generate a different hash for different directories', () => {
+      const key1 = getCacheKey('/foo', 'bar');
+      const key2 = getCacheKey('/bar', 'bar');
+      expect(key1).not.toBe(key2);
+    });
+
+    it('should generate a different hash for different ignore content', () => {
+      const key1 = getCacheKey('/foo', 'bar');
+      const key2 = getCacheKey('/foo', 'baz');
+      expect(key1).not.toBe(key2);
+    });
+
+    it('should generate a different hash for different maxDepth values', () => {
+      const key1 = getCacheKey('/foo', 'bar', 1);
+      const key2 = getCacheKey('/foo', 'bar', 2);
+      const key3 = getCacheKey('/foo', 'bar', undefined);
+      const key4 = getCacheKey('/foo', 'bar');
+      expect(key1).not.toBe(key2);
+      expect(key1).not.toBe(key3);
+      expect(key2).not.toBe(key3);
+      expect(key3).toBe(key4);
+    });
+  });
+
+  describe('in-memory cache operations', () => {
+    beforeEach(() => {
+      // Ensure a clean slate before each test
+      clear();
+    });
+
+    afterEach(() => {
+      // Restore real timers after each test that uses fake ones
+      vi.useRealTimers();
+    });
+
+    it('should write and read data from the cache', () => {
+      const key = 'test-key';
+      const data = ['foo', 'bar'];
+      write(key, data, 10000); // 10 second TTL
+      const cachedData = read(key);
+      expect(cachedData).toEqual(data);
+    });
+
+    it('should return undefined for a nonexistent key', () => {
+      const cachedData = read('nonexistent-key');
+      expect(cachedData).toBeUndefined();
+    });
+
+    it('should clear the cache', () => {
+      const key = 'test-key';
+      const data = ['foo', 'bar'];
+      write(key, data, 10000);
+      clear();
+      const cachedData = read(key);
+      expect(cachedData).toBeUndefined();
+    });
+
+    it('should automatically evict a cache entry after its TTL expires', async () => {
+      vi.useFakeTimers();
+      const key = 'ttl-key';
+      const data = ['foo'];
+      const ttl = 5000; // 5 seconds
+
+      write(key, data, ttl);
+
+      // Should exist immediately after writing
+      expect(read(key)).toEqual(data);
+
+      // Advance time just before expiration
+      await vi.advanceTimersByTimeAsync(ttl - 1);
+      expect(read(key)).toEqual(data);
+
+      // Advance time past expiration
+      await vi.advanceTimersByTimeAsync(1);
+      expect(read(key)).toBeUndefined();
+    });
+
+    it('should reset the timer when an entry is updated', async () => {
+      vi.useFakeTimers();
+      const key = 'update-key';
+      const initialData = ['initial'];
+      const updatedData = ['updated'];
+      const ttl = 5000; // 5 seconds
+
+      // Write initial data
+      write(key, initialData, ttl);
+
+      // Advance time, but not enough to expire
+      await vi.advanceTimersByTimeAsync(3000);
+      expect(read(key)).toEqual(initialData);
+
+      // Update the data, which should reset the timer
+      write(key, updatedData, ttl);
+      expect(read(key)).toEqual(updatedData);
+
+      // Advance time again. If the timer wasn't reset, the total elapsed
+      // time (3000 + 3000 = 6000) would cause an eviction.
+      await vi.advanceTimersByTimeAsync(3000);
+      expect(read(key)).toEqual(updatedData);
+
+      // Advance past the new expiration time
+      await vi.advanceTimersByTimeAsync(2001);
+      expect(read(key)).toBeUndefined();
+    });
+  });
+});

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

@@ -0,0 +1,69 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import crypto from 'node:crypto';
+
+const crawlCache = new Map<string, string[]>();
+const cacheTimers = new Map<string, NodeJS.Timeout>();
+
+/**
+ * Generates a unique cache key based on the project directory and the content
+ * of ignore files. This ensures that the cache is invalidated if the project
+ * or ignore rules change.
+ */
+export const getCacheKey = (
+  directory: string,
+  ignoreContent: string,
+  maxDepth?: number,
+): string => {
+  const hash = crypto.createHash('sha256');
+  hash.update(directory);
+  hash.update(ignoreContent);
+  if (maxDepth !== undefined) {
+    hash.update(String(maxDepth));
+  }
+  return hash.digest('hex');
+};
+
+/**
+ * Reads cached data from the in-memory cache.
+ * Returns undefined if the key is not found.
+ */
+export const read = (key: string): string[] | undefined => crawlCache.get(key);
+
+/**
+ * Writes data to the in-memory cache and sets a timer to evict it after the TTL.
+ */
+export const write = (key: string, results: string[], ttlMs: number): void => {
+  // Clear any existing timer for this key to prevent premature deletion
+  if (cacheTimers.has(key)) {
+    clearTimeout(cacheTimers.get(key)!);
+  }
+
+  // Store the new data
+  crawlCache.set(key, results);
+
+  // Set a timer to automatically delete the cache entry after the TTL
+  const timerId = setTimeout(() => {
+    crawlCache.delete(key);
+    cacheTimers.delete(key);
+  }, ttlMs);
+
+  // Store the timer handle so we can clear it if the entry is updated
+  cacheTimers.set(key, timerId);
+};
+
+/**
+ * Clears the entire cache and all active timers.
+ * Primarily used for testing.
+ */
+export const clear = (): void => {
+  for (const timerId of cacheTimers.values()) {
+    clearTimeout(timerId);
+  }
+  crawlCache.clear();
+  cacheTimers.clear();
+};

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

@@ -0,0 +1,573 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { describe, it, expect, afterEach, vi, beforeEach } from 'vitest';
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import * as cache from './crawlCache.js';
+import { crawl } from './crawler.js';
+import { createTmpDir, cleanupTmpDir } from '@qwen-code/qwen-code-test-utils';
+import { Ignore, loadIgnoreRules } from './ignore.js';
+
+describe('crawler', () => {
+  let tmpDir: string;
+  afterEach(async () => {
+    if (tmpDir) {
+      await cleanupTmpDir(tmpDir);
+    }
+    vi.restoreAllMocks();
+  });
+
+  it('should use .geminiignore rules', async () => {
+    tmpDir = await createTmpDir({
+      '.geminiignore': 'dist/',
+      dist: ['ignored.js'],
+      src: ['not-ignored.js'],
+    });
+
+    const ignore = loadIgnoreRules({
+      projectRoot: tmpDir,
+      useGitignore: false,
+      useGeminiignore: true,
+      ignoreDirs: [],
+    });
+
+    const results = await crawl({
+      crawlDirectory: tmpDir,
+      cwd: tmpDir,
+      ignore,
+      cache: false,
+      cacheTtl: 0,
+    });
+
+    expect(results).toEqual(
+      expect.arrayContaining([
+        '.',
+        'src/',
+        '.geminiignore',
+        'src/not-ignored.js',
+      ]),
+    );
+  });
+
+  it('should combine .gitignore and .geminiignore rules', async () => {
+    tmpDir = await createTmpDir({
+      '.gitignore': 'dist/',
+      '.geminiignore': 'build/',
+      dist: ['ignored-by-git.js'],
+      build: ['ignored-by-gemini.js'],
+      src: ['not-ignored.js'],
+    });
+
+    const ignore = loadIgnoreRules({
+      projectRoot: tmpDir,
+      useGitignore: true,
+      useGeminiignore: true,
+      ignoreDirs: [],
+    });
+
+    const results = await crawl({
+      crawlDirectory: tmpDir,
+      cwd: tmpDir,
+      ignore,
+      cache: false,
+      cacheTtl: 0,
+    });
+
+    expect(results).toEqual(
+      expect.arrayContaining([
+        '.',
+        'src/',
+        '.geminiignore',
+        '.gitignore',
+        'src/not-ignored.js',
+      ]),
+    );
+  });
+
+  it('should use ignoreDirs option', async () => {
+    tmpDir = await createTmpDir({
+      logs: ['some.log'],
+      src: ['main.js'],
+    });
+
+    const ignore = loadIgnoreRules({
+      projectRoot: tmpDir,
+      useGitignore: false,
+      useGeminiignore: false,
+      ignoreDirs: ['logs'],
+    });
+
+    const results = await crawl({
+      crawlDirectory: tmpDir,
+      cwd: tmpDir,
+      ignore,
+      cache: false,
+      cacheTtl: 0,
+    });
+
+    expect(results).toEqual(
+      expect.arrayContaining(['.', 'src/', 'src/main.js']),
+    );
+  });
+
+  it('should handle negated directories', async () => {
+    tmpDir = await createTmpDir({
+      '.gitignore': ['build/**', '!build/public', '!build/public/**'].join(
+        '\n',
+      ),
+      build: {
+        'private.js': '',
+        public: ['index.html'],
+      },
+      src: ['main.js'],
+    });
+
+    const ignore = loadIgnoreRules({
+      projectRoot: tmpDir,
+      useGitignore: true,
+      useGeminiignore: false,
+      ignoreDirs: [],
+    });
+
+    const results = await crawl({
+      crawlDirectory: tmpDir,
+      cwd: tmpDir,
+      ignore,
+      cache: false,
+      cacheTtl: 0,
+    });
+
+    expect(results).toEqual(
+      expect.arrayContaining([
+        '.',
+        'build/',
+        'build/public/',
+        'src/',
+        '.gitignore',
+        'build/public/index.html',
+        'src/main.js',
+      ]),
+    );
+  });
+
+  it('should handle root-level file negation', async () => {
+    tmpDir = await createTmpDir({
+      '.gitignore': ['*.mk', '!Foo.mk'].join('\n'),
+      'bar.mk': '',
+      'Foo.mk': '',
+    });
+
+    const ignore = loadIgnoreRules({
+      projectRoot: tmpDir,
+      useGitignore: true,
+      useGeminiignore: false,
+      ignoreDirs: [],
+    });
+
+    const results = await crawl({
+      crawlDirectory: tmpDir,
+      cwd: tmpDir,
+      ignore,
+      cache: false,
+      cacheTtl: 0,
+    });
+
+    expect(results).toEqual(
+      expect.arrayContaining(['.', '.gitignore', 'Foo.mk', 'bar.mk']),
+    );
+  });
+
+  it('should handle directory negation with glob', async () => {
+    tmpDir = await createTmpDir({
+      '.gitignore': [
+        'third_party/**',
+        '!third_party/foo',
+        '!third_party/foo/bar',
+        '!third_party/foo/bar/baz_buffer',
+      ].join('\n'),
+      third_party: {
+        foo: {
+          bar: {
+            baz_buffer: '',
+          },
+        },
+        ignore_this: '',
+      },
+    });
+
+    const ignore = loadIgnoreRules({
+      projectRoot: tmpDir,
+      useGitignore: true,
+      useGeminiignore: false,
+      ignoreDirs: [],
+    });
+
+    const results = await crawl({
+      crawlDirectory: tmpDir,
+      cwd: tmpDir,
+      ignore,
+      cache: false,
+      cacheTtl: 0,
+    });
+
+    expect(results).toEqual(
+      expect.arrayContaining([
+        '.',
+        'third_party/',
+        'third_party/foo/',
+        'third_party/foo/bar/',
+        '.gitignore',
+        'third_party/foo/bar/baz_buffer',
+      ]),
+    );
+  });
+
+  it('should correctly handle negated patterns in .gitignore', async () => {
+    tmpDir = await createTmpDir({
+      '.gitignore': ['dist/**', '!dist/keep.js'].join('\n'),
+      dist: ['ignore.js', 'keep.js'],
+      src: ['main.js'],
+    });
+
+    const ignore = loadIgnoreRules({
+      projectRoot: tmpDir,
+      useGitignore: true,
+      useGeminiignore: false,
+      ignoreDirs: [],
+    });
+
+    const results = await crawl({
+      crawlDirectory: tmpDir,
+      cwd: tmpDir,
+      ignore,
+      cache: false,
+      cacheTtl: 0,
+    });
+
+    expect(results).toEqual(
+      expect.arrayContaining([
+        '.',
+        'dist/',
+        'src/',
+        '.gitignore',
+        'dist/keep.js',
+        'src/main.js',
+      ]),
+    );
+  });
+
+  it('should initialize correctly when ignore files are missing', async () => {
+    tmpDir = await createTmpDir({
+      src: ['file1.js'],
+    });
+
+    const ignore = loadIgnoreRules({
+      projectRoot: tmpDir,
+      useGitignore: true,
+      useGeminiignore: true,
+      ignoreDirs: [],
+    });
+
+    const results = await crawl({
+      crawlDirectory: tmpDir,
+      cwd: tmpDir,
+      ignore,
+      cache: false,
+      cacheTtl: 0,
+    });
+    expect(results).toEqual(
+      expect.arrayContaining(['.', 'src/', 'src/file1.js']),
+    );
+  });
+
+  it('should handle empty or commented-only ignore files', async () => {
+    tmpDir = await createTmpDir({
+      '.gitignore': '# This is a comment\n\n   \n',
+      src: ['main.js'],
+    });
+
+    const ignore = loadIgnoreRules({
+      projectRoot: tmpDir,
+      useGitignore: true,
+      useGeminiignore: false,
+      ignoreDirs: [],
+    });
+
+    const results = await crawl({
+      crawlDirectory: tmpDir,
+      cwd: tmpDir,
+      ignore,
+      cache: false,
+      cacheTtl: 0,
+    });
+
+    expect(results).toEqual(
+      expect.arrayContaining(['.', 'src/', '.gitignore', 'src/main.js']),
+    );
+  });
+
+  it('should always ignore the .git directory', async () => {
+    tmpDir = await createTmpDir({
+      '.git': ['config', 'HEAD'],
+      src: ['main.js'],
+    });
+
+    const ignore = loadIgnoreRules({
+      projectRoot: tmpDir,
+      useGitignore: false,
+      useGeminiignore: false,
+      ignoreDirs: [],
+    });
+
+    const results = await crawl({
+      crawlDirectory: tmpDir,
+      cwd: tmpDir,
+      ignore,
+      cache: false,
+      cacheTtl: 0,
+    });
+
+    expect(results).toEqual(
+      expect.arrayContaining(['.', 'src/', 'src/main.js']),
+    );
+  });
+
+  describe('with in-memory cache', () => {
+    beforeEach(() => {
+      cache.clear();
+      vi.useFakeTimers();
+    });
+
+    afterEach(() => {
+      vi.useRealTimers();
+    });
+
+    it('should hit the cache for subsequent crawls', async () => {
+      tmpDir = await createTmpDir({ 'file1.js': '' });
+      const ignore = loadIgnoreRules({
+        projectRoot: tmpDir,
+        useGitignore: false,
+        useGeminiignore: false,
+        ignoreDirs: [],
+      });
+      const options = {
+        crawlDirectory: tmpDir,
+        cwd: tmpDir,
+        ignore,
+        cache: true,
+        cacheTtl: 10,
+      };
+
+      const crawlSpy = vi.spyOn(cache, 'read');
+
+      await crawl(options);
+      expect(crawlSpy).toHaveBeenCalledTimes(1);
+
+      await crawl(options);
+      expect(crawlSpy).toHaveBeenCalledTimes(2);
+      // fdir should not have been called a second time.
+      // We can't spy on it directly, but we can check the cache was hit.
+      const cacheKey = cache.getCacheKey(
+        options.crawlDirectory,
+        options.ignore.getFingerprint(),
+        undefined,
+      );
+      expect(cache.read(cacheKey)).toBeDefined();
+    });
+
+    it('should miss the cache when ignore rules change', async () => {
+      tmpDir = await createTmpDir({
+        '.gitignore': 'a.txt',
+        'a.txt': '',
+        'b.txt': '',
+      });
+      const getIgnore = () =>
+        loadIgnoreRules({
+          projectRoot: tmpDir,
+          useGitignore: true,
+          useGeminiignore: false,
+          ignoreDirs: [],
+        });
+      const getOptions = (ignore: Ignore) => ({
+        crawlDirectory: tmpDir,
+        cwd: tmpDir,
+        ignore,
+        cache: true,
+        cacheTtl: 10000,
+      });
+
+      // Initial crawl to populate the cache
+      const ignore1 = getIgnore();
+      const results1 = await crawl(getOptions(ignore1));
+      expect(results1).toEqual(
+        expect.arrayContaining(['.', '.gitignore', 'b.txt']),
+      );
+
+      // Modify the ignore file
+      await fs.writeFile(path.join(tmpDir, '.gitignore'), 'b.txt');
+
+      // Second crawl should miss the cache and trigger a recrawl
+      const ignore2 = getIgnore();
+      const results2 = await crawl(getOptions(ignore2));
+      expect(results2).toEqual(
+        expect.arrayContaining(['.', '.gitignore', 'a.txt']),
+      );
+    });
+
+    it('should miss the cache after TTL expires', async () => {
+      tmpDir = await createTmpDir({ 'file1.js': '' });
+      const ignore = loadIgnoreRules({
+        projectRoot: tmpDir,
+        useGitignore: false,
+        useGeminiignore: false,
+        ignoreDirs: [],
+      });
+      const options = {
+        crawlDirectory: tmpDir,
+        cwd: tmpDir,
+        ignore,
+        cache: true,
+        cacheTtl: 10, // 10 seconds
+      };
+
+      const readSpy = vi.spyOn(cache, 'read');
+      const writeSpy = vi.spyOn(cache, 'write');
+
+      await crawl(options);
+      expect(readSpy).toHaveBeenCalledTimes(1);
+      expect(writeSpy).toHaveBeenCalledTimes(1);
+
+      // Advance time past the TTL
+      await vi.advanceTimersByTimeAsync(11000);
+
+      await crawl(options);
+      expect(readSpy).toHaveBeenCalledTimes(2);
+      expect(writeSpy).toHaveBeenCalledTimes(2);
+    });
+
+    it('should miss the cache when maxDepth changes', async () => {
+      tmpDir = await createTmpDir({ 'file1.js': '' });
+      const ignore = loadIgnoreRules({
+        projectRoot: tmpDir,
+        useGitignore: false,
+        useGeminiignore: false,
+        ignoreDirs: [],
+      });
+      const getOptions = (maxDepth?: number) => ({
+        crawlDirectory: tmpDir,
+        cwd: tmpDir,
+        ignore,
+        cache: true,
+        cacheTtl: 10000,
+        maxDepth,
+      });
+
+      const readSpy = vi.spyOn(cache, 'read');
+      const writeSpy = vi.spyOn(cache, 'write');
+
+      // 1. First crawl with maxDepth: 1
+      await crawl(getOptions(1));
+      expect(readSpy).toHaveBeenCalledTimes(1);
+      expect(writeSpy).toHaveBeenCalledTimes(1);
+
+      // 2. Second crawl with maxDepth: 2, should be a cache miss
+      await crawl(getOptions(2));
+      expect(readSpy).toHaveBeenCalledTimes(2);
+      expect(writeSpy).toHaveBeenCalledTimes(2);
+
+      // 3. Third crawl with maxDepth: 1 again, should be a cache hit.
+      await crawl(getOptions(1));
+      expect(readSpy).toHaveBeenCalledTimes(3);
+      expect(writeSpy).toHaveBeenCalledTimes(2); // No new write
+    });
+  });
+
+  describe('with maxDepth', () => {
+    beforeEach(async () => {
+      tmpDir = await createTmpDir({
+        'file-root.txt': '',
+        level1: {
+          'file-level1.txt': '',
+          level2: {
+            'file-level2.txt': '',
+            level3: {
+              'file-level3.txt': '',
+            },
+          },
+        },
+      });
+    });
+
+    const getCrawlResults = (maxDepth?: number) => {
+      const ignore = loadIgnoreRules({
+        projectRoot: tmpDir,
+        useGitignore: false,
+        useGeminiignore: false,
+        ignoreDirs: [],
+      });
+      return crawl({
+        crawlDirectory: tmpDir,
+        cwd: tmpDir,
+        ignore,
+        cache: false,
+        cacheTtl: 0,
+        maxDepth,
+      });
+    };
+
+    it('should only crawl top-level files when maxDepth is 0', async () => {
+      const results = await getCrawlResults(0);
+      expect(results).toEqual(
+        expect.arrayContaining(['.', 'level1/', 'file-root.txt']),
+      );
+    });
+
+    it('should crawl one level deep when maxDepth is 1', async () => {
+      const results = await getCrawlResults(1);
+      expect(results).toEqual(
+        expect.arrayContaining([
+          '.',
+          'level1/',
+          'level1/level2/',
+          'file-root.txt',
+          'level1/file-level1.txt',
+        ]),
+      );
+    });
+
+    it('should crawl two levels deep when maxDepth is 2', async () => {
+      const results = await getCrawlResults(2);
+      expect(results).toEqual(
+        expect.arrayContaining([
+          '.',
+          'level1/',
+          'level1/level2/',
+          'level1/level2/level3/',
+          'file-root.txt',
+          'level1/file-level1.txt',
+          'level1/level2/file-level2.txt',
+        ]),
+      );
+    });
+
+    it('should perform a full recursive crawl when maxDepth is undefined', async () => {
+      const results = await getCrawlResults(undefined);
+      expect(results).toEqual(
+        expect.arrayContaining([
+          '.',
+          'level1/',
+          'level1/level2/',
+          'level1/level2/level3/',
+          'file-root.txt',
+          'level1/file-level1.txt',
+          'level1/level2/file-level2.txt',
+          'level1/level2/level3/file-level3.txt',
+        ]),
+      );
+    });
+  });
+});

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

@@ -0,0 +1,85 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import path from 'node:path';
+import { fdir } from 'fdir';
+import { Ignore } from './ignore.js';
+import * as cache from './crawlCache.js';
+
+export interface CrawlOptions {
+  // The directory to start the crawl from.
+  crawlDirectory: string;
+  // The project's root directory, for path relativity.
+  cwd: string;
+  // The fdir maxDepth option.
+  maxDepth?: number;
+  // A pre-configured Ignore instance.
+  ignore: Ignore;
+  // Caching options.
+  cache: boolean;
+  cacheTtl: number;
+}
+
+function toPosixPath(p: string) {
+  return p.split(path.sep).join(path.posix.sep);
+}
+
+export async function crawl(options: CrawlOptions): Promise<string[]> {
+  if (options.cache) {
+    const cacheKey = cache.getCacheKey(
+      options.crawlDirectory,
+      options.ignore.getFingerprint(),
+      options.maxDepth,
+    );
+    const cachedResults = cache.read(cacheKey);
+
+    if (cachedResults) {
+      return cachedResults;
+    }
+  }
+
+  const posixCwd = toPosixPath(options.cwd);
+  const posixCrawlDirectory = toPosixPath(options.crawlDirectory);
+
+  let results: string[];
+  try {
+    const dirFilter = options.ignore.getDirectoryFilter();
+    const api = new fdir()
+      .withRelativePaths()
+      .withDirs()
+      .withPathSeparator('/') // Always use unix style paths
+      .exclude((_, dirPath) => {
+        const relativePath = path.posix.relative(posixCrawlDirectory, dirPath);
+        return dirFilter(`${relativePath}/`);
+      });
+
+    if (options.maxDepth !== undefined) {
+      api.withMaxDepth(options.maxDepth);
+    }
+
+    results = await api.crawl(options.crawlDirectory).withPromise();
+  } catch (_e) {
+    // The directory probably doesn't exist.
+    return [];
+  }
+
+  const relativeToCrawlDir = path.posix.relative(posixCwd, posixCrawlDirectory);
+
+  const relativeToCwdResults = results.map((p) =>
+    path.posix.join(relativeToCrawlDir, p),
+  );
+
+  if (options.cache) {
+    const cacheKey = cache.getCacheKey(
+      options.crawlDirectory,
+      options.ignore.getFingerprint(),
+      options.maxDepth,
+    );
+    cache.write(cacheKey, relativeToCwdResults, options.cacheTtl * 1000);
+  }
+
+  return relativeToCwdResults;
+}

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

@@ -0,0 +1,662 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { describe, it, expect, afterEach, vi } from 'vitest';
+import { FileSearchFactory, AbortError, filter } from './fileSearch.js';
+import { createTmpDir, cleanupTmpDir } from '@qwen-code/qwen-code-test-utils';
+
+describe('FileSearch', () => {
+  let tmpDir: string;
+  afterEach(async () => {
+    if (tmpDir) {
+      await cleanupTmpDir(tmpDir);
+    }
+    vi.restoreAllMocks();
+  });
+
+  it('should use .geminiignore rules', async () => {
+    tmpDir = await createTmpDir({
+      '.geminiignore': 'dist/',
+      dist: ['ignored.js'],
+      src: ['not-ignored.js'],
+    });
+
+    const fileSearch = FileSearchFactory.create({
+      projectRoot: tmpDir,
+      useGitignore: false,
+      useGeminiignore: true,
+      ignoreDirs: [],
+      cache: false,
+      cacheTtl: 0,
+      enableRecursiveFileSearch: true,
+    });
+
+    await fileSearch.initialize();
+    const results = await fileSearch.search('');
+
+    expect(results).toEqual(['src/', '.geminiignore', 'src/not-ignored.js']);
+  });
+
+  it('should combine .gitignore and .geminiignore rules', async () => {
+    tmpDir = await createTmpDir({
+      '.gitignore': 'dist/',
+      '.geminiignore': 'build/',
+      dist: ['ignored-by-git.js'],
+      build: ['ignored-by-gemini.js'],
+      src: ['not-ignored.js'],
+    });
+
+    const fileSearch = FileSearchFactory.create({
+      projectRoot: tmpDir,
+      useGitignore: true,
+      useGeminiignore: true,
+      ignoreDirs: [],
+      cache: false,
+      cacheTtl: 0,
+      enableRecursiveFileSearch: true,
+    });
+
+    await fileSearch.initialize();
+    const results = await fileSearch.search('');
+
+    expect(results).toEqual([
+      'src/',
+      '.geminiignore',
+      '.gitignore',
+      'src/not-ignored.js',
+    ]);
+  });
+
+  it('should use ignoreDirs option', async () => {
+    tmpDir = await createTmpDir({
+      logs: ['some.log'],
+      src: ['main.js'],
+    });
+
+    const fileSearch = FileSearchFactory.create({
+      projectRoot: tmpDir,
+      useGitignore: false,
+      useGeminiignore: false,
+      ignoreDirs: ['logs'],
+      cache: false,
+      cacheTtl: 0,
+      enableRecursiveFileSearch: true,
+    });
+
+    await fileSearch.initialize();
+    const results = await fileSearch.search('');
+
+    expect(results).toEqual(['src/', 'src/main.js']);
+  });
+
+  it('should handle negated directories', async () => {
+    tmpDir = await createTmpDir({
+      '.gitignore': ['build/**', '!build/public', '!build/public/**'].join(
+        '\n',
+      ),
+      build: {
+        'private.js': '',
+        public: ['index.html'],
+      },
+      src: ['main.js'],
+    });
+
+    const fileSearch = FileSearchFactory.create({
+      projectRoot: tmpDir,
+      useGitignore: true,
+      useGeminiignore: false,
+      ignoreDirs: [],
+      cache: false,
+      cacheTtl: 0,
+      enableRecursiveFileSearch: true,
+    });
+
+    await fileSearch.initialize();
+    const results = await fileSearch.search('');
+
+    expect(results).toEqual([
+      'build/',
+      'build/public/',
+      'src/',
+      '.gitignore',
+      'build/public/index.html',
+      'src/main.js',
+    ]);
+  });
+
+  it('should filter results with a search pattern', async () => {
+    tmpDir = await createTmpDir({
+      src: {
+        'main.js': '',
+        'util.ts': '',
+        'style.css': '',
+      },
+    });
+
+    const fileSearch = FileSearchFactory.create({
+      projectRoot: tmpDir,
+      useGitignore: false,
+      useGeminiignore: false,
+      ignoreDirs: [],
+      cache: false,
+      cacheTtl: 0,
+      enableRecursiveFileSearch: true,
+    });
+
+    await fileSearch.initialize();
+    const results = await fileSearch.search('**/*.js');
+
+    expect(results).toEqual(['src/main.js']);
+  });
+
+  it('should handle root-level file negation', async () => {
+    tmpDir = await createTmpDir({
+      '.gitignore': ['*.mk', '!Foo.mk'].join('\n'),
+      'bar.mk': '',
+      'Foo.mk': '',
+    });
+
+    const fileSearch = FileSearchFactory.create({
+      projectRoot: tmpDir,
+      useGitignore: true,
+      useGeminiignore: false,
+      ignoreDirs: [],
+      cache: false,
+      cacheTtl: 0,
+      enableRecursiveFileSearch: true,
+    });
+
+    await fileSearch.initialize();
+    const results = await fileSearch.search('');
+
+    expect(results).toEqual(['.gitignore', 'Foo.mk']);
+  });
+
+  it('should handle directory negation with glob', async () => {
+    tmpDir = await createTmpDir({
+      '.gitignore': [
+        'third_party/**',
+        '!third_party/foo',
+        '!third_party/foo/bar',
+        '!third_party/foo/bar/baz_buffer',
+      ].join('\n'),
+      third_party: {
+        foo: {
+          bar: {
+            baz_buffer: '',
+          },
+        },
+        ignore_this: '',
+      },
+    });
+
+    const fileSearch = FileSearchFactory.create({
+      projectRoot: tmpDir,
+      useGitignore: true,
+      useGeminiignore: false,
+      ignoreDirs: [],
+      cache: false,
+      cacheTtl: 0,
+      enableRecursiveFileSearch: true,
+    });
+
+    await fileSearch.initialize();
+    const results = await fileSearch.search('');
+
+    expect(results).toEqual([
+      'third_party/',
+      'third_party/foo/',
+      'third_party/foo/bar/',
+      '.gitignore',
+      'third_party/foo/bar/baz_buffer',
+    ]);
+  });
+
+  it('should correctly handle negated patterns in .gitignore', async () => {
+    tmpDir = await createTmpDir({
+      '.gitignore': ['dist/**', '!dist/keep.js'].join('\n'),
+      dist: ['ignore.js', 'keep.js'],
+      src: ['main.js'],
+    });
+
+    const fileSearch = FileSearchFactory.create({
+      projectRoot: tmpDir,
+      useGitignore: true,
+      useGeminiignore: false,
+      ignoreDirs: [],
+      cache: false,
+      cacheTtl: 0,
+      enableRecursiveFileSearch: true,
+    });
+
+    await fileSearch.initialize();
+    const results = await fileSearch.search('');
+
+    expect(results).toEqual([
+      'dist/',
+      'src/',
+      '.gitignore',
+      'dist/keep.js',
+      'src/main.js',
+    ]);
+  });
+
+  // New test cases start here
+
+  it('should initialize correctly when ignore files are missing', async () => {
+    tmpDir = await createTmpDir({
+      src: ['file1.js'],
+    });
+
+    const fileSearch = FileSearchFactory.create({
+      projectRoot: tmpDir,
+      useGitignore: true,
+      useGeminiignore: true,
+      ignoreDirs: [],
+      cache: false,
+      cacheTtl: 0,
+      enableRecursiveFileSearch: true,
+    });
+
+    // Expect no errors to be thrown during initialization
+    await expect(fileSearch.initialize()).resolves.toBeUndefined();
+    const results = await fileSearch.search('');
+    expect(results).toEqual(['src/', 'src/file1.js']);
+  });
+
+  it('should respect maxResults option in search', async () => {
+    tmpDir = await createTmpDir({
+      src: {
+        'file1.js': '',
+        'file2.js': '',
+        'file3.js': '',
+        'file4.js': '',
+      },
+    });
+
+    const fileSearch = FileSearchFactory.create({
+      projectRoot: tmpDir,
+      useGitignore: false,
+      useGeminiignore: false,
+      ignoreDirs: [],
+      cache: false,
+      cacheTtl: 0,
+      enableRecursiveFileSearch: true,
+    });
+
+    await fileSearch.initialize();
+    const results = await fileSearch.search('**/*.js', { maxResults: 2 });
+
+    expect(results).toEqual(['src/file1.js', 'src/file2.js']); // Assuming alphabetical sort
+  });
+
+  it('should use fzf for fuzzy matching when pattern does not contain wildcards', async () => {
+    tmpDir = await createTmpDir({
+      src: {
+        'main.js': '',
+        'util.ts': '',
+        'style.css': '',
+      },
+    });
+
+    const fileSearch = FileSearchFactory.create({
+      projectRoot: tmpDir,
+      useGitignore: false,
+      useGeminiignore: false,
+      ignoreDirs: [],
+      cache: false,
+      cacheTtl: 0,
+      enableRecursiveFileSearch: true,
+    });
+
+    await fileSearch.initialize();
+    const results = await fileSearch.search('sst');
+
+    expect(results).toEqual(['src/style.css']);
+  });
+
+  it('should return empty array when no matches are found', async () => {
+    tmpDir = await createTmpDir({
+      src: ['file1.js'],
+    });
+
+    const fileSearch = FileSearchFactory.create({
+      projectRoot: tmpDir,
+      useGitignore: false,
+      useGeminiignore: false,
+      ignoreDirs: [],
+      cache: false,
+      cacheTtl: 0,
+      enableRecursiveFileSearch: true,
+    });
+
+    await fileSearch.initialize();
+    const results = await fileSearch.search('nonexistent-file.xyz');
+
+    expect(results).toEqual([]);
+  });
+
+  it('should throw AbortError when filter is aborted', async () => {
+    const controller = new AbortController();
+    const dummyPaths = Array.from({ length: 5000 }, (_, i) => `file${i}.js`); // Large array to ensure yielding
+
+    const filterPromise = filter(dummyPaths, '*.js', controller.signal);
+
+    // Abort after a short delay to ensure filter has started
+    setTimeout(() => controller.abort(), 1);
+
+    await expect(filterPromise).rejects.toThrow(AbortError);
+  });
+
+  it('should throw an error if search is called before initialization', async () => {
+    tmpDir = await createTmpDir({});
+    const fileSearch = FileSearchFactory.create({
+      projectRoot: tmpDir,
+      useGitignore: false,
+      useGeminiignore: false,
+      ignoreDirs: [],
+      cache: false,
+      cacheTtl: 0,
+      enableRecursiveFileSearch: true,
+    });
+
+    await expect(fileSearch.search('')).rejects.toThrow(
+      'Engine not initialized. Call initialize() first.',
+    );
+  });
+
+  it('should handle empty or commented-only ignore files', async () => {
+    tmpDir = await createTmpDir({
+      '.gitignore': '# This is a comment\n\n   \n',
+      src: ['main.js'],
+    });
+
+    const fileSearch = FileSearchFactory.create({
+      projectRoot: tmpDir,
+      useGitignore: true,
+      useGeminiignore: false,
+      ignoreDirs: [],
+      cache: false,
+      cacheTtl: 0,
+      enableRecursiveFileSearch: true,
+    });
+
+    await fileSearch.initialize();
+    const results = await fileSearch.search('');
+
+    expect(results).toEqual(['src/', '.gitignore', 'src/main.js']);
+  });
+
+  it('should always ignore the .git directory', async () => {
+    tmpDir = await createTmpDir({
+      '.git': ['config', 'HEAD'],
+      src: ['main.js'],
+    });
+
+    const fileSearch = FileSearchFactory.create({
+      projectRoot: tmpDir,
+      useGitignore: false, // Explicitly disable .gitignore to isolate this rule
+      useGeminiignore: false,
+      ignoreDirs: [],
+      cache: false,
+      cacheTtl: 0,
+      enableRecursiveFileSearch: true,
+    });
+
+    await fileSearch.initialize();
+    const results = await fileSearch.search('');
+
+    expect(results).toEqual(['src/', 'src/main.js']);
+  });
+
+  it('should be cancellable via AbortSignal', async () => {
+    const largeDir: Record<string, string> = {};
+    for (let i = 0; i < 100; i++) {
+      largeDir[`file${i}.js`] = '';
+    }
+    tmpDir = await createTmpDir(largeDir);
+
+    const fileSearch = FileSearchFactory.create({
+      projectRoot: tmpDir,
+      useGitignore: false,
+      useGeminiignore: false,
+      ignoreDirs: [],
+      cache: false,
+      cacheTtl: 0,
+      enableRecursiveFileSearch: true,
+    });
+
+    await fileSearch.initialize();
+
+    const controller = new AbortController();
+    const searchPromise = fileSearch.search('**/*.js', {
+      signal: controller.signal,
+    });
+
+    // Yield to allow the search to start before aborting.
+    await new Promise((resolve) => setImmediate(resolve));
+
+    controller.abort();
+
+    await expect(searchPromise).rejects.toThrow(AbortError);
+  });
+
+  it('should leverage ResultCache for bestBaseQuery optimization', async () => {
+    tmpDir = await createTmpDir({
+      src: {
+        'foo.js': '',
+        'bar.ts': '',
+        nested: {
+          'baz.js': '',
+        },
+      },
+    });
+
+    const fileSearch = FileSearchFactory.create({
+      projectRoot: tmpDir,
+      useGitignore: false,
+      useGeminiignore: false,
+      ignoreDirs: [],
+      cache: true, // Enable caching for this test
+      cacheTtl: 0,
+      enableRecursiveFileSearch: true,
+    });
+
+    await fileSearch.initialize();
+
+    // Perform a broad search to prime the cache
+    const broadResults = await fileSearch.search('src/**');
+    expect(broadResults).toEqual([
+      'src/',
+      'src/nested/',
+      'src/bar.ts',
+      'src/foo.js',
+      'src/nested/baz.js',
+    ]);
+
+    // Perform a more specific search that should leverage the broad search's cached results
+    const specificResults = await fileSearch.search('src/**/*.js');
+    expect(specificResults).toEqual(['src/foo.js', 'src/nested/baz.js']);
+
+    // Although we can't directly inspect ResultCache.hits/misses from here,
+    // the correctness of specificResults after a broad search implicitly
+    // verifies that the caching mechanism, including bestBaseQuery, is working.
+  });
+
+  it('should be case-insensitive by default', async () => {
+    tmpDir = await createTmpDir({
+      'File1.Js': '',
+      'file2.js': '',
+      'FILE3.JS': '',
+      'other.txt': '',
+    });
+
+    const fileSearch = FileSearchFactory.create({
+      projectRoot: tmpDir,
+      useGitignore: false,
+      useGeminiignore: false,
+      ignoreDirs: [],
+      cache: false,
+      cacheTtl: 0,
+      enableRecursiveFileSearch: true,
+    });
+
+    await fileSearch.initialize();
+
+    // Search with a lowercase pattern
+    let results = await fileSearch.search('file*.js');
+    expect(results).toHaveLength(3);
+    expect(results).toEqual(
+      expect.arrayContaining(['File1.Js', 'file2.js', 'FILE3.JS']),
+    );
+
+    // Search with an uppercase pattern
+    results = await fileSearch.search('FILE*.JS');
+    expect(results).toHaveLength(3);
+    expect(results).toEqual(
+      expect.arrayContaining(['File1.Js', 'file2.js', 'FILE3.JS']),
+    );
+
+    // Search with a mixed-case pattern
+    results = await fileSearch.search('FiLe*.Js');
+    expect(results).toHaveLength(3);
+    expect(results).toEqual(
+      expect.arrayContaining(['File1.Js', 'file2.js', 'FILE3.JS']),
+    );
+  });
+
+  it('should respect maxResults even when the cache returns an exact match', async () => {
+    tmpDir = await createTmpDir({
+      'file1.js': '',
+      'file2.js': '',
+      'file3.js': '',
+      'file4.js': '',
+      'file5.js': '',
+    });
+
+    const fileSearch = FileSearchFactory.create({
+      projectRoot: tmpDir,
+      useGitignore: false,
+      useGeminiignore: false,
+      ignoreDirs: [],
+      cache: true, // Ensure caching is enabled
+      cacheTtl: 10000,
+      enableRecursiveFileSearch: true,
+    });
+
+    await fileSearch.initialize();
+
+    // 1. Perform a broad search to populate the cache with an exact match.
+    const initialResults = await fileSearch.search('*.js');
+    expect(initialResults).toEqual([
+      'file1.js',
+      'file2.js',
+      'file3.js',
+      'file4.js',
+      'file5.js',
+    ]);
+
+    // 2. Perform the same search again, but this time with a maxResults limit.
+    const limitedResults = await fileSearch.search('*.js', { maxResults: 2 });
+
+    // 3. Assert that the maxResults limit was respected, even with a cache hit.
+    expect(limitedResults).toEqual(['file1.js', 'file2.js']);
+  });
+
+  describe('DirectoryFileSearch', () => {
+    it('should search for files in the current directory', async () => {
+      tmpDir = await createTmpDir({
+        'file1.js': '',
+        'file2.ts': '',
+        'file3.js': '',
+      });
+
+      const fileSearch = FileSearchFactory.create({
+        projectRoot: tmpDir,
+        useGitignore: false,
+        useGeminiignore: false,
+        ignoreDirs: [],
+        cache: false,
+        cacheTtl: 0,
+        enableRecursiveFileSearch: false,
+      });
+
+      await fileSearch.initialize();
+      const results = await fileSearch.search('*.js');
+      expect(results).toEqual(['file1.js', 'file3.js']);
+    });
+
+    it('should search for files in a subdirectory', async () => {
+      tmpDir = await createTmpDir({
+        'file1.js': '',
+        src: {
+          'file2.js': '',
+          'file3.ts': '',
+        },
+      });
+
+      const fileSearch = FileSearchFactory.create({
+        projectRoot: tmpDir,
+        useGitignore: false,
+        useGeminiignore: false,
+        ignoreDirs: [],
+        cache: false,
+        cacheTtl: 0,
+        enableRecursiveFileSearch: false,
+      });
+
+      await fileSearch.initialize();
+      const results = await fileSearch.search('src/*.js');
+      expect(results).toEqual(['src/file2.js']);
+    });
+
+    it('should list all files in a directory', async () => {
+      tmpDir = await createTmpDir({
+        'file1.js': '',
+        src: {
+          'file2.js': '',
+          'file3.ts': '',
+        },
+      });
+
+      const fileSearch = FileSearchFactory.create({
+        projectRoot: tmpDir,
+        useGitignore: false,
+        useGeminiignore: false,
+        ignoreDirs: [],
+        cache: false,
+        cacheTtl: 0,
+        enableRecursiveFileSearch: false,
+      });
+
+      await fileSearch.initialize();
+      const results = await fileSearch.search('src/');
+      expect(results).toEqual(['src/file2.js', 'src/file3.ts']);
+    });
+
+    it('should respect ignore rules', async () => {
+      tmpDir = await createTmpDir({
+        '.gitignore': '*.js',
+        'file1.js': '',
+        'file2.ts': '',
+      });
+
+      const fileSearch = FileSearchFactory.create({
+        projectRoot: tmpDir,
+        useGitignore: true,
+        useGeminiignore: false,
+        ignoreDirs: [],
+        cache: false,
+        cacheTtl: 0,
+        enableRecursiveFileSearch: false,
+      });
+
+      await fileSearch.initialize();
+      const results = await fileSearch.search('*');
+      expect(results).toEqual(['.gitignore', 'file2.ts']);
+    });
+  });
+});

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

@@ -0,0 +1,237 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import path from 'node:path';
+import picomatch from 'picomatch';
+import { Ignore, loadIgnoreRules } from './ignore.js';
+import { ResultCache } from './result-cache.js';
+import { crawl } from './crawler.js';
+import { AsyncFzf, FzfResultItem } from 'fzf';
+
+export interface FileSearchOptions {
+  projectRoot: string;
+  ignoreDirs: string[];
+  useGitignore: boolean;
+  useGeminiignore: boolean;
+  cache: boolean;
+  cacheTtl: number;
+  enableRecursiveFileSearch: boolean;
+  maxDepth?: number;
+}
+
+export class AbortError extends Error {
+  constructor(message = 'Search aborted') {
+    super(message);
+    this.name = 'AbortError';
+  }
+}
+
+/**
+ * Filters a list of paths based on a given pattern.
+ * @param allPaths The list of all paths to filter.
+ * @param pattern The picomatch pattern to filter by.
+ * @param signal An AbortSignal to cancel the operation.
+ * @returns A promise that resolves to the filtered and sorted list of paths.
+ */
+export async function filter(
+  allPaths: string[],
+  pattern: string,
+  signal: AbortSignal | undefined,
+): Promise<string[]> {
+  const patternFilter = picomatch(pattern, {
+    dot: true,
+    contains: true,
+    nocase: true,
+  });
+
+  const results: string[] = [];
+  for (const [i, p] of allPaths.entries()) {
+    // Yield control to the event loop periodically to prevent blocking.
+    if (i % 1000 === 0) {
+      await new Promise((resolve) => setImmediate(resolve));
+      if (signal?.aborted) {
+        throw new AbortError();
+      }
+    }
+
+    if (patternFilter(p)) {
+      results.push(p);
+    }
+  }
+
+  results.sort((a, b) => {
+    const aIsDir = a.endsWith('/');
+    const bIsDir = b.endsWith('/');
+
+    if (aIsDir && !bIsDir) return -1;
+    if (!aIsDir && bIsDir) return 1;
+
+    // This is 40% faster than localeCompare and the only thing we would really
+    // gain from localeCompare is case-sensitive sort
+    return a < b ? -1 : a > b ? 1 : 0;
+  });
+
+  return results;
+}
+
+export interface SearchOptions {
+  signal?: AbortSignal;
+  maxResults?: number;
+}
+
+export interface FileSearch {
+  initialize(): Promise<void>;
+  search(pattern: string, options?: SearchOptions): Promise<string[]>;
+}
+
+class RecursiveFileSearch implements FileSearch {
+  private ignore: Ignore | undefined;
+  private resultCache: ResultCache | undefined;
+  private allFiles: string[] = [];
+  private fzf: AsyncFzf<string[]> | undefined;
+
+  constructor(private readonly options: FileSearchOptions) {}
+
+  async initialize(): Promise<void> {
+    this.ignore = loadIgnoreRules(this.options);
+    this.allFiles = await crawl({
+      crawlDirectory: this.options.projectRoot,
+      cwd: this.options.projectRoot,
+      ignore: this.ignore,
+      cache: this.options.cache,
+      cacheTtl: this.options.cacheTtl,
+      maxDepth: this.options.maxDepth,
+    });
+    this.buildResultCache();
+  }
+
+  async search(
+    pattern: string,
+    options: SearchOptions = {},
+  ): Promise<string[]> {
+    if (!this.resultCache || !this.fzf || !this.ignore) {
+      throw new Error('Engine not initialized. Call initialize() first.');
+    }
+
+    pattern = pattern || '*';
+
+    let filteredCandidates;
+    const { files: candidates, isExactMatch } =
+      await this.resultCache!.get(pattern);
+
+    if (isExactMatch) {
+      // Use the cached result.
+      filteredCandidates = candidates;
+    } else {
+      let shouldCache = true;
+      if (pattern.includes('*')) {
+        filteredCandidates = await filter(candidates, pattern, options.signal);
+      } else {
+        filteredCandidates = await this.fzf
+          .find(pattern)
+          .then((results: Array<FzfResultItem<string>>) =>
+            results.map((entry: FzfResultItem<string>) => entry.item),
+          )
+          .catch(() => {
+            shouldCache = false;
+            return [];
+          });
+      }
+
+      if (shouldCache) {
+        this.resultCache!.set(pattern, filteredCandidates);
+      }
+    }
+
+    const fileFilter = this.ignore.getFileFilter();
+    const results: string[] = [];
+    for (const [i, candidate] of filteredCandidates.entries()) {
+      if (i % 1000 === 0) {
+        await new Promise((resolve) => setImmediate(resolve));
+        if (options.signal?.aborted) {
+          throw new AbortError();
+        }
+      }
+
+      if (results.length >= (options.maxResults ?? Infinity)) {
+        break;
+      }
+      if (candidate === '.') {
+        continue;
+      }
+      if (!fileFilter(candidate)) {
+        results.push(candidate);
+      }
+    }
+    return results;
+  }
+
+  private buildResultCache(): void {
+    this.resultCache = new ResultCache(this.allFiles);
+    // The v1 algorithm is much faster since it only looks at the first
+    // occurence of the pattern. We use it for search spaces that have >20k
+    // files, because the v2 algorithm is just too slow in those cases.
+    this.fzf = new AsyncFzf(this.allFiles, {
+      fuzzy: this.allFiles.length > 20000 ? 'v1' : 'v2',
+    });
+  }
+}
+
+class DirectoryFileSearch implements FileSearch {
+  private ignore: Ignore | undefined;
+
+  constructor(private readonly options: FileSearchOptions) {}
+
+  async initialize(): Promise<void> {
+    this.ignore = loadIgnoreRules(this.options);
+  }
+
+  async search(
+    pattern: string,
+    options: SearchOptions = {},
+  ): Promise<string[]> {
+    if (!this.ignore) {
+      throw new Error('Engine not initialized. Call initialize() first.');
+    }
+    pattern = pattern || '*';
+
+    const dir = pattern.endsWith('/') ? pattern : path.dirname(pattern);
+    const results = await crawl({
+      crawlDirectory: path.join(this.options.projectRoot, dir),
+      cwd: this.options.projectRoot,
+      maxDepth: 0,
+      ignore: this.ignore,
+      cache: this.options.cache,
+      cacheTtl: this.options.cacheTtl,
+    });
+
+    const filteredResults = await filter(results, pattern, options.signal);
+
+    const fileFilter = this.ignore.getFileFilter();
+    const finalResults: string[] = [];
+    for (const candidate of filteredResults) {
+      if (finalResults.length >= (options.maxResults ?? Infinity)) {
+        break;
+      }
+      if (candidate === '.') {
+        continue;
+      }
+      if (!fileFilter(candidate)) {
+        finalResults.push(candidate);
+      }
+    }
+    return finalResults;
+  }
+}
+
+export class FileSearchFactory {
+  static create(options: FileSearchOptions): FileSearch {
+    if (options.enableRecursiveFileSearch) {
+      return new RecursiveFileSearch(options);
+    }
+    return new DirectoryFileSearch(options);
+  }
+}

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

@@ -0,0 +1,160 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { describe, it, expect, afterEach } from 'vitest';
+import { Ignore, loadIgnoreRules } from './ignore.js';
+import { createTmpDir, cleanupTmpDir } from '@qwen-code/qwen-code-test-utils';
+
+describe('Ignore', () => {
+  describe('getDirectoryFilter', () => {
+    it('should ignore directories matching directory patterns', () => {
+      const ig = new Ignore().add(['foo/', 'bar/']);
+      const dirFilter = ig.getDirectoryFilter();
+      expect(dirFilter('foo/')).toBe(true);
+      expect(dirFilter('bar/')).toBe(true);
+      expect(dirFilter('baz/')).toBe(false);
+    });
+
+    it('should not ignore directories with file patterns', () => {
+      const ig = new Ignore().add(['foo.js', '*.log']);
+      const dirFilter = ig.getDirectoryFilter();
+      expect(dirFilter('foo.js')).toBe(false);
+      expect(dirFilter('foo.log')).toBe(false);
+    });
+  });
+
+  describe('getFileFilter', () => {
+    it('should not ignore files with directory patterns', () => {
+      const ig = new Ignore().add(['foo/', 'bar/']);
+      const fileFilter = ig.getFileFilter();
+      expect(fileFilter('foo')).toBe(false);
+      expect(fileFilter('foo/file.txt')).toBe(false);
+    });
+
+    it('should ignore files matching file patterns', () => {
+      const ig = new Ignore().add(['*.log', 'foo.js']);
+      const fileFilter = ig.getFileFilter();
+      expect(fileFilter('foo.log')).toBe(true);
+      expect(fileFilter('foo.js')).toBe(true);
+      expect(fileFilter('bar.txt')).toBe(false);
+    });
+  });
+
+  it('should accumulate patterns across multiple add() calls', () => {
+    const ig = new Ignore().add('foo.js');
+    ig.add('bar.js');
+    const fileFilter = ig.getFileFilter();
+    expect(fileFilter('foo.js')).toBe(true);
+    expect(fileFilter('bar.js')).toBe(true);
+    expect(fileFilter('baz.js')).toBe(false);
+  });
+
+  it('should return a stable and consistent fingerprint', () => {
+    const ig1 = new Ignore().add(['foo', '!bar']);
+    const ig2 = new Ignore().add('foo\n!bar');
+
+    // Fingerprints should be identical for the same rules.
+    expect(ig1.getFingerprint()).toBe(ig2.getFingerprint());
+
+    // Adding a new rule should change the fingerprint.
+    ig2.add('baz');
+    expect(ig1.getFingerprint()).not.toBe(ig2.getFingerprint());
+  });
+});
+
+describe('loadIgnoreRules', () => {
+  let tmpDir: string;
+
+  afterEach(async () => {
+    if (tmpDir) {
+      await cleanupTmpDir(tmpDir);
+    }
+  });
+
+  it('should load rules from .gitignore', async () => {
+    tmpDir = await createTmpDir({
+      '.gitignore': '*.log',
+    });
+    const ignore = loadIgnoreRules({
+      projectRoot: tmpDir,
+      useGitignore: true,
+      useGeminiignore: false,
+      ignoreDirs: [],
+    });
+    const fileFilter = ignore.getFileFilter();
+    expect(fileFilter('test.log')).toBe(true);
+    expect(fileFilter('test.txt')).toBe(false);
+  });
+
+  it('should load rules from .geminiignore', async () => {
+    tmpDir = await createTmpDir({
+      '.geminiignore': '*.log',
+    });
+    const ignore = loadIgnoreRules({
+      projectRoot: tmpDir,
+      useGitignore: false,
+      useGeminiignore: true,
+      ignoreDirs: [],
+    });
+    const fileFilter = ignore.getFileFilter();
+    expect(fileFilter('test.log')).toBe(true);
+    expect(fileFilter('test.txt')).toBe(false);
+  });
+
+  it('should combine rules from .gitignore and .geminiignore', async () => {
+    tmpDir = await createTmpDir({
+      '.gitignore': '*.log',
+      '.geminiignore': '*.txt',
+    });
+    const ignore = loadIgnoreRules({
+      projectRoot: tmpDir,
+      useGitignore: true,
+      useGeminiignore: true,
+      ignoreDirs: [],
+    });
+    const fileFilter = ignore.getFileFilter();
+    expect(fileFilter('test.log')).toBe(true);
+    expect(fileFilter('test.txt')).toBe(true);
+    expect(fileFilter('test.md')).toBe(false);
+  });
+
+  it('should add ignoreDirs', async () => {
+    tmpDir = await createTmpDir({});
+    const ignore = loadIgnoreRules({
+      projectRoot: tmpDir,
+      useGitignore: false,
+      useGeminiignore: false,
+      ignoreDirs: ['logs/'],
+    });
+    const dirFilter = ignore.getDirectoryFilter();
+    expect(dirFilter('logs/')).toBe(true);
+    expect(dirFilter('src/')).toBe(false);
+  });
+
+  it('should handle missing ignore files gracefully', async () => {
+    tmpDir = await createTmpDir({});
+    const ignore = loadIgnoreRules({
+      projectRoot: tmpDir,
+      useGitignore: true,
+      useGeminiignore: true,
+      ignoreDirs: [],
+    });
+    const fileFilter = ignore.getFileFilter();
+    expect(fileFilter('anyfile.txt')).toBe(false);
+  });
+
+  it('should always add .git to the ignore list', async () => {
+    tmpDir = await createTmpDir({});
+    const ignore = loadIgnoreRules({
+      projectRoot: tmpDir,
+      useGitignore: false,
+      useGeminiignore: false,
+      ignoreDirs: [],
+    });
+    const dirFilter = ignore.getDirectoryFilter();
+    expect(dirFilter('.git/')).toBe(true);
+  });
+});

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

@@ -0,0 +1,131 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import fs from 'node:fs';
+import path from 'node:path';
+import ignore from 'ignore';
+import picomatch from 'picomatch';
+
+const hasFileExtension = picomatch('**/*[*.]*');
+
+export interface LoadIgnoreRulesOptions {
+  projectRoot: string;
+  useGitignore: boolean;
+  useGeminiignore: boolean;
+  ignoreDirs: string[];
+}
+
+export function loadIgnoreRules(options: LoadIgnoreRulesOptions): Ignore {
+  const ignorer = new Ignore();
+  if (options.useGitignore) {
+    const gitignorePath = path.join(options.projectRoot, '.gitignore');
+    if (fs.existsSync(gitignorePath)) {
+      ignorer.add(fs.readFileSync(gitignorePath, 'utf8'));
+    }
+  }
+
+  if (options.useGeminiignore) {
+    const geminiignorePath = path.join(options.projectRoot, '.geminiignore');
+    if (fs.existsSync(geminiignorePath)) {
+      ignorer.add(fs.readFileSync(geminiignorePath, 'utf8'));
+    }
+  }
+
+  const ignoreDirs = ['.git', ...options.ignoreDirs];
+  ignorer.add(
+    ignoreDirs.map((dir) => {
+      if (dir.endsWith('/')) {
+        return dir;
+      }
+      return `${dir}/`;
+    }),
+  );
+
+  return ignorer;
+}
+
+export class Ignore {
+  private readonly allPatterns: string[] = [];
+  private dirIgnorer = ignore();
+  private fileIgnorer = ignore();
+
+  /**
+   * Adds one or more ignore patterns.
+   * @param patterns A single pattern string or an array of pattern strings.
+   *                 Each pattern can be a glob-like string similar to .gitignore rules.
+   * @returns The `Ignore` instance for chaining.
+   */
+  add(patterns: string | string[]): this {
+    if (typeof patterns === 'string') {
+      patterns = patterns.split(/\r?\n/);
+    }
+
+    for (const p of patterns) {
+      const pattern = p.trim();
+
+      if (pattern === '' || pattern.startsWith('#')) {
+        continue;
+      }
+
+      this.allPatterns.push(pattern);
+
+      const isPositiveDirPattern =
+        pattern.endsWith('/') && !pattern.startsWith('!');
+
+      if (isPositiveDirPattern) {
+        this.dirIgnorer.add(pattern);
+      } else {
+        // An ambiguous pattern (e.g., "build") could match a file or a
+        // directory. To optimize the file system crawl, we use a heuristic:
+        // patterns without a dot in the last segment are included in the
+        // directory exclusion check.
+        //
+        // This heuristic can fail. For example, an ignore pattern of "my.assets"
+        // intended to exclude a directory will not be treated as a directory
+        // pattern because it contains a ".". This results in crawling a
+        // directory that should have been excluded, reducing efficiency.
+        // Correctness is still maintained. The incorrectly crawled directory
+        // will be filtered out by the final ignore check.
+        //
+        // For maximum crawl efficiency, users should explicitly mark directory
+        // patterns with a trailing slash (e.g., "my.assets/").
+        this.fileIgnorer.add(pattern);
+        if (!hasFileExtension(pattern)) {
+          this.dirIgnorer.add(pattern);
+        }
+      }
+    }
+
+    return this;
+  }
+
+  /**
+   * Returns a predicate that matches explicit directory ignore patterns (patterns ending with '/').
+   * @returns {(dirPath: string) => boolean}
+   */
+  getDirectoryFilter(): (dirPath: string) => boolean {
+    return (dirPath: string) => this.dirIgnorer.ignores(dirPath);
+  }
+
+  /**
+   * Returns a predicate that matches file ignore patterns (all patterns not ending with '/').
+   * Note: This may also match directories if a file pattern matches a directory name, but all explicit directory patterns are handled by getDirectoryFilter.
+   * @returns {(filePath: string) => boolean}
+   */
+  getFileFilter(): (filePath: string) => boolean {
+    return (filePath: string) => this.fileIgnorer.ignores(filePath);
+  }
+
+  /**
+   * Returns a string representing the current set of ignore patterns.
+   * This can be used to generate a unique identifier for the ignore configuration,
+   * useful for caching purposes.
+   * @returns A string fingerprint of the ignore patterns.
+   */
+  getFingerprint(): string {
+    return this.allPatterns.join('\n');
+  }
+}

projects/ui/qwen-code/packages/core/src/utils/filesearch/result-cache.test.ts

@@ -0,0 +1,55 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { test, expect } from 'vitest';
+import { ResultCache } from './result-cache.js';
+
+test('ResultCache basic usage', async () => {
+  const files = [
+    'foo.txt',
+    'bar.js',
+    'baz.md',
+    'subdir/file.txt',
+    'subdir/other.js',
+    'subdir/nested/file.md',
+  ];
+  const cache = new ResultCache(files);
+  const { files: resultFiles, isExactMatch } = await cache.get('*.js');
+  expect(resultFiles).toEqual(files);
+  expect(isExactMatch).toBe(false);
+});
+
+test('ResultCache cache hit/miss', async () => {
+  const files = ['foo.txt', 'bar.js', 'baz.md'];
+  const cache = new ResultCache(files);
+  // First call: miss
+  const { files: result1Files, isExactMatch: isExactMatch1 } =
+    await cache.get('*.js');
+  expect(result1Files).toEqual(files);
+  expect(isExactMatch1).toBe(false);
+
+  // Simulate FileSearch applying the filter and setting the result
+  cache.set('*.js', ['bar.js']);
+
+  // Second call: hit
+  const { files: result2Files, isExactMatch: isExactMatch2 } =
+    await cache.get('*.js');
+  expect(result2Files).toEqual(['bar.js']);
+  expect(isExactMatch2).toBe(true);
+});
+
+test('ResultCache best base query', async () => {
+  const files = ['foo.txt', 'foobar.js', 'baz.md'];
+  const cache = new ResultCache(files);
+
+  // Cache a broader query
+  cache.set('foo', ['foo.txt', 'foobar.js']);
+
+  // Search for a more specific query that starts with the broader one
+  const { files: resultFiles, isExactMatch } = await cache.get('foobar');
+  expect(resultFiles).toEqual(['foo.txt', 'foobar.js']);
+  expect(isExactMatch).toBe(false);
+});