Add files using upload-large-folder tool

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

@@ -0,0 +1,558 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import {
+  vi,
+  describe,
+  it,
+  expect,
+  beforeEach,
+  afterEach,
+  type Mock,
+} from 'vitest';
+import {
+  checkHasEditorType,
+  getDiffCommand,
+  openDiff,
+  allowEditorTypeInSandbox,
+  isEditorAvailable,
+  type EditorType,
+} from './editor.js';
+import { execSync, spawn } from 'child_process';
+
+vi.mock('child_process', () => ({
+  execSync: vi.fn(),
+  spawn: vi.fn(),
+}));
+
+const originalPlatform = process.platform;
+
+describe('editor utils', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    vi.unstubAllEnvs();
+    Object.defineProperty(process, 'platform', {
+      value: originalPlatform,
+      writable: true,
+    });
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+    vi.unstubAllEnvs();
+    Object.defineProperty(process, 'platform', {
+      value: originalPlatform,
+      writable: true,
+    });
+  });
+
+  describe('checkHasEditorType', () => {
+    const testCases: Array<{
+      editor: EditorType;
+      commands: string[];
+      win32Commands: string[];
+    }> = [
+      { editor: 'vscode', commands: ['code'], win32Commands: ['code.cmd'] },
+      {
+        editor: 'vscodium',
+        commands: ['codium'],
+        win32Commands: ['codium.cmd'],
+      },
+      {
+        editor: 'windsurf',
+        commands: ['windsurf'],
+        win32Commands: ['windsurf'],
+      },
+      { editor: 'cursor', commands: ['cursor'], win32Commands: ['cursor'] },
+      { editor: 'vim', commands: ['vim'], win32Commands: ['vim'] },
+      { editor: 'neovim', commands: ['nvim'], win32Commands: ['nvim'] },
+      { editor: 'zed', commands: ['zed', 'zeditor'], win32Commands: ['zed'] },
+      { editor: 'emacs', commands: ['emacs'], win32Commands: ['emacs.exe'] },
+    ];
+
+    for (const { editor, commands, win32Commands } of testCases) {
+      describe(`${editor}`, () => {
+        // Non-windows tests
+        it(`should return true if first command "${commands[0]}" exists on non-windows`, () => {
+          Object.defineProperty(process, 'platform', { value: 'linux' });
+          (execSync as Mock).mockReturnValue(
+            Buffer.from(`/usr/bin/${commands[0]}`),
+          );
+          expect(checkHasEditorType(editor)).toBe(true);
+          expect(execSync).toHaveBeenCalledWith(`command -v ${commands[0]}`, {
+            stdio: 'ignore',
+          });
+        });
+
+        if (commands.length > 1) {
+          it(`should return true if first command doesn't exist but second command "${commands[1]}" exists on non-windows`, () => {
+            Object.defineProperty(process, 'platform', { value: 'linux' });
+            (execSync as Mock)
+              .mockImplementationOnce(() => {
+                throw new Error(); // first command not found
+              })
+              .mockReturnValueOnce(Buffer.from(`/usr/bin/${commands[1]}`)); // second command found
+            expect(checkHasEditorType(editor)).toBe(true);
+            expect(execSync).toHaveBeenCalledTimes(2);
+          });
+        }
+
+        it(`should return false if none of the commands exist on non-windows`, () => {
+          Object.defineProperty(process, 'platform', { value: 'linux' });
+          (execSync as Mock).mockImplementation(() => {
+            throw new Error(); // all commands not found
+          });
+          expect(checkHasEditorType(editor)).toBe(false);
+          expect(execSync).toHaveBeenCalledTimes(commands.length);
+        });
+
+        // Windows tests
+        it(`should return true if first command "${win32Commands[0]}" exists on windows`, () => {
+          Object.defineProperty(process, 'platform', { value: 'win32' });
+          (execSync as Mock).mockReturnValue(
+            Buffer.from(`C:\\Program Files\\...\\${win32Commands[0]}`),
+          );
+          expect(checkHasEditorType(editor)).toBe(true);
+          expect(execSync).toHaveBeenCalledWith(
+            `where.exe ${win32Commands[0]}`,
+            {
+              stdio: 'ignore',
+            },
+          );
+        });
+
+        if (win32Commands.length > 1) {
+          it(`should return true if first command doesn't exist but second command "${win32Commands[1]}" exists on windows`, () => {
+            Object.defineProperty(process, 'platform', { value: 'win32' });
+            (execSync as Mock)
+              .mockImplementationOnce(() => {
+                throw new Error(); // first command not found
+              })
+              .mockReturnValueOnce(
+                Buffer.from(`C:\\Program Files\\...\\${win32Commands[1]}`),
+              ); // second command found
+            expect(checkHasEditorType(editor)).toBe(true);
+            expect(execSync).toHaveBeenCalledTimes(2);
+          });
+        }
+
+        it(`should return false if none of the commands exist on windows`, () => {
+          Object.defineProperty(process, 'platform', { value: 'win32' });
+          (execSync as Mock).mockImplementation(() => {
+            throw new Error(); // all commands not found
+          });
+          expect(checkHasEditorType(editor)).toBe(false);
+          expect(execSync).toHaveBeenCalledTimes(win32Commands.length);
+        });
+      });
+    }
+  });
+
+  describe('getDiffCommand', () => {
+    const guiEditors: Array<{
+      editor: EditorType;
+      commands: string[];
+      win32Commands: string[];
+    }> = [
+      { editor: 'vscode', commands: ['code'], win32Commands: ['code.cmd'] },
+      {
+        editor: 'vscodium',
+        commands: ['codium'],
+        win32Commands: ['codium.cmd'],
+      },
+      {
+        editor: 'windsurf',
+        commands: ['windsurf'],
+        win32Commands: ['windsurf'],
+      },
+      { editor: 'cursor', commands: ['cursor'], win32Commands: ['cursor'] },
+      { editor: 'zed', commands: ['zed', 'zeditor'], win32Commands: ['zed'] },
+    ];
+
+    for (const { editor, commands, win32Commands } of guiEditors) {
+      // Non-windows tests
+      it(`should use first command "${commands[0]}" when it exists on non-windows`, () => {
+        Object.defineProperty(process, 'platform', { value: 'linux' });
+        (execSync as Mock).mockReturnValue(
+          Buffer.from(`/usr/bin/${commands[0]}`),
+        );
+        const diffCommand = getDiffCommand('old.txt', 'new.txt', editor);
+        expect(diffCommand).toEqual({
+          command: commands[0],
+          args: ['--wait', '--diff', 'old.txt', 'new.txt'],
+        });
+      });
+
+      if (commands.length > 1) {
+        it(`should use second command "${commands[1]}" when first doesn't exist on non-windows`, () => {
+          Object.defineProperty(process, 'platform', { value: 'linux' });
+          (execSync as Mock)
+            .mockImplementationOnce(() => {
+              throw new Error(); // first command not found
+            })
+            .mockReturnValueOnce(Buffer.from(`/usr/bin/${commands[1]}`)); // second command found
+
+          const diffCommand = getDiffCommand('old.txt', 'new.txt', editor);
+          expect(diffCommand).toEqual({
+            command: commands[1],
+            args: ['--wait', '--diff', 'old.txt', 'new.txt'],
+          });
+        });
+      }
+
+      it(`should fall back to last command "${commands[commands.length - 1]}" when none exist on non-windows`, () => {
+        Object.defineProperty(process, 'platform', { value: 'linux' });
+        (execSync as Mock).mockImplementation(() => {
+          throw new Error(); // all commands not found
+        });
+
+        const diffCommand = getDiffCommand('old.txt', 'new.txt', editor);
+        expect(diffCommand).toEqual({
+          command: commands[commands.length - 1],
+          args: ['--wait', '--diff', 'old.txt', 'new.txt'],
+        });
+      });
+
+      // Windows tests
+      it(`should use first command "${win32Commands[0]}" when it exists on windows`, () => {
+        Object.defineProperty(process, 'platform', { value: 'win32' });
+        (execSync as Mock).mockReturnValue(
+          Buffer.from(`C:\\Program Files\\...\\${win32Commands[0]}`),
+        );
+        const diffCommand = getDiffCommand('old.txt', 'new.txt', editor);
+        expect(diffCommand).toEqual({
+          command: win32Commands[0],
+          args: ['--wait', '--diff', 'old.txt', 'new.txt'],
+        });
+      });
+
+      if (win32Commands.length > 1) {
+        it(`should use second command "${win32Commands[1]}" when first doesn't exist on windows`, () => {
+          Object.defineProperty(process, 'platform', { value: 'win32' });
+          (execSync as Mock)
+            .mockImplementationOnce(() => {
+              throw new Error(); // first command not found
+            })
+            .mockReturnValueOnce(
+              Buffer.from(`C:\\Program Files\\...\\${win32Commands[1]}`),
+            ); // second command found
+
+          const diffCommand = getDiffCommand('old.txt', 'new.txt', editor);
+          expect(diffCommand).toEqual({
+            command: win32Commands[1],
+            args: ['--wait', '--diff', 'old.txt', 'new.txt'],
+          });
+        });
+      }
+
+      it(`should fall back to last command "${win32Commands[win32Commands.length - 1]}" when none exist on windows`, () => {
+        Object.defineProperty(process, 'platform', { value: 'win32' });
+        (execSync as Mock).mockImplementation(() => {
+          throw new Error(); // all commands not found
+        });
+
+        const diffCommand = getDiffCommand('old.txt', 'new.txt', editor);
+        expect(diffCommand).toEqual({
+          command: win32Commands[win32Commands.length - 1],
+          args: ['--wait', '--diff', 'old.txt', 'new.txt'],
+        });
+      });
+    }
+
+    const terminalEditors: Array<{
+      editor: EditorType;
+      command: string;
+    }> = [
+      { editor: 'vim', command: 'vim' },
+      { editor: 'neovim', command: 'nvim' },
+    ];
+
+    for (const { editor, command } of terminalEditors) {
+      it(`should return the correct command for ${editor}`, () => {
+        const diffCommand = getDiffCommand('old.txt', 'new.txt', editor);
+        expect(diffCommand).toEqual({
+          command,
+          args: [
+            '-d',
+            '-i',
+            'NONE',
+            '-c',
+            'wincmd h | set readonly | wincmd l',
+            '-c',
+            'highlight DiffAdd cterm=bold ctermbg=22 guibg=#005f00 | highlight DiffChange cterm=bold ctermbg=24 guibg=#005f87 | highlight DiffText ctermbg=21 guibg=#0000af | highlight DiffDelete ctermbg=52 guibg=#5f0000',
+            '-c',
+            'set showtabline=2 | set tabline=[Instructions]\\ :wqa(save\\ &\\ quit)\\ \\|\\ i/esc(toggle\\ edit\\ mode)',
+            '-c',
+            'wincmd h | setlocal statusline=OLD\\ FILE',
+            '-c',
+            'wincmd l | setlocal statusline=%#StatusBold#NEW\\ FILE\\ :wqa(save\\ &\\ quit)\\ \\|\\ i/esc(toggle\\ edit\\ mode)',
+            '-c',
+            'autocmd WinClosed * wqa',
+            'old.txt',
+            'new.txt',
+          ],
+        });
+      });
+    }
+
+    it('should return the correct command for emacs', () => {
+      const command = getDiffCommand('old.txt', 'new.txt', 'emacs');
+      expect(command).toEqual({
+        command: 'emacs',
+        args: ['--eval', '(ediff "old.txt" "new.txt")'],
+      });
+    });
+
+    it('should return null for an unsupported editor', () => {
+      // @ts-expect-error Testing unsupported editor
+      const command = getDiffCommand('old.txt', 'new.txt', 'foobar');
+      expect(command).toBeNull();
+    });
+  });
+
+  describe('openDiff', () => {
+    const spawnEditors: EditorType[] = [
+      'vscode',
+      'vscodium',
+      'windsurf',
+      'cursor',
+      'zed',
+    ];
+    for (const editor of spawnEditors) {
+      it(`should call spawn for ${editor}`, async () => {
+        const mockSpawn = {
+          on: vi.fn((event, cb) => {
+            if (event === 'close') {
+              cb(0);
+            }
+          }),
+        };
+        (spawn as Mock).mockReturnValue(mockSpawn);
+        await openDiff('old.txt', 'new.txt', editor, () => {});
+        const diffCommand = getDiffCommand('old.txt', 'new.txt', editor)!;
+        expect(spawn).toHaveBeenCalledWith(
+          diffCommand.command,
+          diffCommand.args,
+          {
+            stdio: 'inherit',
+            shell: true,
+          },
+        );
+        expect(mockSpawn.on).toHaveBeenCalledWith(
+          'close',
+          expect.any(Function),
+        );
+        expect(mockSpawn.on).toHaveBeenCalledWith(
+          'error',
+          expect.any(Function),
+        );
+      });
+
+      it(`should reject if spawn for ${editor} fails`, async () => {
+        const mockError = new Error('spawn error');
+        const mockSpawn = {
+          on: vi.fn((event, cb) => {
+            if (event === 'error') {
+              cb(mockError);
+            }
+          }),
+        };
+        (spawn as Mock).mockReturnValue(mockSpawn);
+        await expect(
+          openDiff('old.txt', 'new.txt', editor, () => {}),
+        ).rejects.toThrow('spawn error');
+      });
+
+      it(`should reject if ${editor} exits with non-zero code`, async () => {
+        const mockSpawn = {
+          on: vi.fn((event, cb) => {
+            if (event === 'close') {
+              cb(1);
+            }
+          }),
+        };
+        (spawn as Mock).mockReturnValue(mockSpawn);
+        await expect(
+          openDiff('old.txt', 'new.txt', editor, () => {}),
+        ).rejects.toThrow(`${editor} exited with code 1`);
+      });
+    }
+
+    const execSyncEditors: EditorType[] = ['vim', 'neovim', 'emacs'];
+    for (const editor of execSyncEditors) {
+      it(`should call execSync for ${editor} on non-windows`, async () => {
+        Object.defineProperty(process, 'platform', { value: 'linux' });
+        await openDiff('old.txt', 'new.txt', editor, () => {});
+        expect(execSync).toHaveBeenCalledTimes(1);
+        const diffCommand = getDiffCommand('old.txt', 'new.txt', editor)!;
+        const expectedCommand = `${
+          diffCommand.command
+        } ${diffCommand.args.map((arg) => `"${arg}"`).join(' ')}`;
+        expect(execSync).toHaveBeenCalledWith(expectedCommand, {
+          stdio: 'inherit',
+          encoding: 'utf8',
+        });
+      });
+
+      it(`should call execSync for ${editor} on windows`, async () => {
+        Object.defineProperty(process, 'platform', { value: 'win32' });
+        await openDiff('old.txt', 'new.txt', editor, () => {});
+        expect(execSync).toHaveBeenCalledTimes(1);
+        const diffCommand = getDiffCommand('old.txt', 'new.txt', editor)!;
+        const expectedCommand = `${diffCommand.command} ${diffCommand.args.join(
+          ' ',
+        )}`;
+        expect(execSync).toHaveBeenCalledWith(expectedCommand, {
+          stdio: 'inherit',
+          encoding: 'utf8',
+        });
+      });
+    }
+
+    it('should log an error if diff command is not available', async () => {
+      const consoleErrorSpy = vi
+        .spyOn(console, 'error')
+        .mockImplementation(() => {});
+      // @ts-expect-error Testing unsupported editor
+      await openDiff('old.txt', 'new.txt', 'foobar', () => {});
+      expect(consoleErrorSpy).toHaveBeenCalledWith(
+        'No diff tool available. Install a supported editor.',
+      );
+    });
+
+    describe('onEditorClose callback', () => {
+      it('should call onEditorClose for execSync editors', async () => {
+        (execSync as Mock).mockReturnValue(Buffer.from(`/usr/bin/`));
+        const onEditorClose = vi.fn();
+        await openDiff('old.txt', 'new.txt', 'vim', onEditorClose);
+        expect(execSync).toHaveBeenCalledTimes(1);
+        expect(onEditorClose).toHaveBeenCalledTimes(1);
+      });
+
+      it('should call onEditorClose for execSync editors when an error is thrown', async () => {
+        (execSync as Mock).mockImplementation(() => {
+          throw new Error('test error');
+        });
+        const onEditorClose = vi.fn();
+        openDiff('old.txt', 'new.txt', 'vim', onEditorClose);
+        expect(execSync).toHaveBeenCalledTimes(1);
+        expect(onEditorClose).toHaveBeenCalledTimes(1);
+      });
+
+      it('should not call onEditorClose for spawn editors', async () => {
+        const onEditorClose = vi.fn();
+        const mockSpawn = {
+          on: vi.fn((event, cb) => {
+            if (event === 'close') {
+              cb(0);
+            }
+          }),
+        };
+        (spawn as Mock).mockReturnValue(mockSpawn);
+        await openDiff('old.txt', 'new.txt', 'vscode', onEditorClose);
+        expect(spawn).toHaveBeenCalledTimes(1);
+        expect(onEditorClose).not.toHaveBeenCalled();
+      });
+    });
+  });
+
+  describe('allowEditorTypeInSandbox', () => {
+    it('should allow vim in sandbox mode', () => {
+      vi.stubEnv('SANDBOX', 'sandbox');
+      expect(allowEditorTypeInSandbox('vim')).toBe(true);
+    });
+
+    it('should allow vim when not in sandbox mode', () => {
+      expect(allowEditorTypeInSandbox('vim')).toBe(true);
+    });
+
+    it('should allow emacs in sandbox mode', () => {
+      vi.stubEnv('SANDBOX', 'sandbox');
+      expect(allowEditorTypeInSandbox('emacs')).toBe(true);
+    });
+
+    it('should allow emacs when not in sandbox mode', () => {
+      expect(allowEditorTypeInSandbox('emacs')).toBe(true);
+    });
+
+    it('should allow neovim in sandbox mode', () => {
+      vi.stubEnv('SANDBOX', 'sandbox');
+      expect(allowEditorTypeInSandbox('neovim')).toBe(true);
+    });
+
+    it('should allow neovim when not in sandbox mode', () => {
+      expect(allowEditorTypeInSandbox('neovim')).toBe(true);
+    });
+
+    const guiEditors: EditorType[] = [
+      'vscode',
+      'vscodium',
+      'windsurf',
+      'cursor',
+      'zed',
+    ];
+    for (const editor of guiEditors) {
+      it(`should not allow ${editor} in sandbox mode`, () => {
+        vi.stubEnv('SANDBOX', 'sandbox');
+        expect(allowEditorTypeInSandbox(editor)).toBe(false);
+      });
+
+      it(`should allow ${editor} when not in sandbox mode`, () => {
+        expect(allowEditorTypeInSandbox(editor)).toBe(true);
+      });
+    }
+  });
+
+  describe('isEditorAvailable', () => {
+    it('should return false for undefined editor', () => {
+      expect(isEditorAvailable(undefined)).toBe(false);
+    });
+
+    it('should return false for empty string editor', () => {
+      expect(isEditorAvailable('')).toBe(false);
+    });
+
+    it('should return false for invalid editor type', () => {
+      expect(isEditorAvailable('invalid-editor')).toBe(false);
+    });
+
+    it('should return true for vscode when installed and not in sandbox mode', () => {
+      (execSync as Mock).mockReturnValue(Buffer.from('/usr/bin/code'));
+      expect(isEditorAvailable('vscode')).toBe(true);
+    });
+
+    it('should return false for vscode when not installed and not in sandbox mode', () => {
+      (execSync as Mock).mockImplementation(() => {
+        throw new Error();
+      });
+      expect(isEditorAvailable('vscode')).toBe(false);
+    });
+
+    it('should return false for vscode when installed and in sandbox mode', () => {
+      (execSync as Mock).mockReturnValue(Buffer.from('/usr/bin/code'));
+      vi.stubEnv('SANDBOX', 'sandbox');
+      expect(isEditorAvailable('vscode')).toBe(false);
+    });
+
+    it('should return true for vim when installed and in sandbox mode', () => {
+      (execSync as Mock).mockReturnValue(Buffer.from('/usr/bin/vim'));
+      vi.stubEnv('SANDBOX', 'sandbox');
+      expect(isEditorAvailable('vim')).toBe(true);
+    });
+
+    it('should return true for emacs when installed and in sandbox mode', () => {
+      (execSync as Mock).mockReturnValue(Buffer.from('/usr/bin/emacs'));
+      vi.stubEnv('SANDBOX', 'sandbox');
+      expect(isEditorAvailable('emacs')).toBe(true);
+    });
+
+    it('should return true for neovim when installed and in sandbox mode', () => {
+      (execSync as Mock).mockReturnValue(Buffer.from('/usr/bin/nvim'));
+      vi.stubEnv('SANDBOX', 'sandbox');
+      expect(isEditorAvailable('neovim')).toBe(true);
+    });
+  });
+});

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

@@ -0,0 +1,229 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { execSync, spawn } from 'child_process';
+
+export type EditorType =
+  | 'vscode'
+  | 'vscodium'
+  | 'windsurf'
+  | 'cursor'
+  | 'vim'
+  | 'neovim'
+  | 'zed'
+  | 'emacs';
+
+function isValidEditorType(editor: string): editor is EditorType {
+  return [
+    'vscode',
+    'vscodium',
+    'windsurf',
+    'cursor',
+    'vim',
+    'neovim',
+    'zed',
+    'emacs',
+  ].includes(editor);
+}
+
+interface DiffCommand {
+  command: string;
+  args: string[];
+}
+
+function commandExists(cmd: string): boolean {
+  try {
+    execSync(
+      process.platform === 'win32' ? `where.exe ${cmd}` : `command -v ${cmd}`,
+      { stdio: 'ignore' },
+    );
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Editor command configurations for different platforms.
+ * Each editor can have multiple possible command names, listed in order of preference.
+ */
+const editorCommands: Record<
+  EditorType,
+  { win32: string[]; default: string[] }
+> = {
+  vscode: { win32: ['code.cmd'], default: ['code'] },
+  vscodium: { win32: ['codium.cmd'], default: ['codium'] },
+  windsurf: { win32: ['windsurf'], default: ['windsurf'] },
+  cursor: { win32: ['cursor'], default: ['cursor'] },
+  vim: { win32: ['vim'], default: ['vim'] },
+  neovim: { win32: ['nvim'], default: ['nvim'] },
+  zed: { win32: ['zed'], default: ['zed', 'zeditor'] },
+  emacs: { win32: ['emacs.exe'], default: ['emacs'] },
+};
+
+export function checkHasEditorType(editor: EditorType): boolean {
+  const commandConfig = editorCommands[editor];
+  const commands =
+    process.platform === 'win32' ? commandConfig.win32 : commandConfig.default;
+  return commands.some((cmd) => commandExists(cmd));
+}
+
+export function allowEditorTypeInSandbox(editor: EditorType): boolean {
+  const notUsingSandbox = !process.env['SANDBOX'];
+  if (['vscode', 'vscodium', 'windsurf', 'cursor', 'zed'].includes(editor)) {
+    return notUsingSandbox;
+  }
+  // For terminal-based editors like vim and emacs, allow in sandbox.
+  return true;
+}
+
+/**
+ * Check if the editor is valid and can be used.
+ * Returns false if preferred editor is not set / invalid / not available / not allowed in sandbox.
+ */
+export function isEditorAvailable(editor: string | undefined): boolean {
+  if (editor && isValidEditorType(editor)) {
+    return checkHasEditorType(editor) && allowEditorTypeInSandbox(editor);
+  }
+  return false;
+}
+
+/**
+ * Get the diff command for a specific editor.
+ */
+export function getDiffCommand(
+  oldPath: string,
+  newPath: string,
+  editor: EditorType,
+): DiffCommand | null {
+  if (!isValidEditorType(editor)) {
+    return null;
+  }
+  const commandConfig = editorCommands[editor];
+  const commands =
+    process.platform === 'win32' ? commandConfig.win32 : commandConfig.default;
+  const command =
+    commands.slice(0, -1).find((cmd) => commandExists(cmd)) ||
+    commands[commands.length - 1];
+
+  switch (editor) {
+    case 'vscode':
+    case 'vscodium':
+    case 'windsurf':
+    case 'cursor':
+    case 'zed':
+      return { command, args: ['--wait', '--diff', oldPath, newPath] };
+    case 'vim':
+    case 'neovim':
+      return {
+        command,
+        args: [
+          '-d',
+          // skip viminfo file to avoid E138 errors
+          '-i',
+          'NONE',
+          // make the left window read-only and the right window editable
+          '-c',
+          'wincmd h | set readonly | wincmd l',
+          // set up colors for diffs
+          '-c',
+          'highlight DiffAdd cterm=bold ctermbg=22 guibg=#005f00 | highlight DiffChange cterm=bold ctermbg=24 guibg=#005f87 | highlight DiffText ctermbg=21 guibg=#0000af | highlight DiffDelete ctermbg=52 guibg=#5f0000',
+          // Show helpful messages
+          '-c',
+          'set showtabline=2 | set tabline=[Instructions]\\ :wqa(save\\ &\\ quit)\\ \\|\\ i/esc(toggle\\ edit\\ mode)',
+          '-c',
+          'wincmd h | setlocal statusline=OLD\\ FILE',
+          '-c',
+          'wincmd l | setlocal statusline=%#StatusBold#NEW\\ FILE\\ :wqa(save\\ &\\ quit)\\ \\|\\ i/esc(toggle\\ edit\\ mode)',
+          // Auto close all windows when one is closed
+          '-c',
+          'autocmd WinClosed * wqa',
+          oldPath,
+          newPath,
+        ],
+      };
+    case 'emacs':
+      return {
+        command: 'emacs',
+        args: ['--eval', `(ediff "${oldPath}" "${newPath}")`],
+      };
+    default:
+      return null;
+  }
+}
+
+/**
+ * Opens a diff tool to compare two files.
+ * Terminal-based editors by default blocks parent process until the editor exits.
+ * GUI-based editors require args such as "--wait" to block parent process.
+ */
+export async function openDiff(
+  oldPath: string,
+  newPath: string,
+  editor: EditorType,
+  onEditorClose: () => void,
+): Promise<void> {
+  const diffCommand = getDiffCommand(oldPath, newPath, editor);
+  if (!diffCommand) {
+    console.error('No diff tool available. Install a supported editor.');
+    return;
+  }
+
+  try {
+    switch (editor) {
+      case 'vscode':
+      case 'vscodium':
+      case 'windsurf':
+      case 'cursor':
+      case 'zed':
+        // Use spawn for GUI-based editors to avoid blocking the entire process
+        return new Promise((resolve, reject) => {
+          const childProcess = spawn(diffCommand.command, diffCommand.args, {
+            stdio: 'inherit',
+            shell: true,
+          });
+
+          childProcess.on('close', (code) => {
+            if (code === 0) {
+              resolve();
+            } else {
+              reject(new Error(`${editor} exited with code ${code}`));
+            }
+          });
+
+          childProcess.on('error', (error) => {
+            reject(error);
+          });
+        });
+
+      case 'vim':
+      case 'emacs':
+      case 'neovim': {
+        // Use execSync for terminal-based editors
+        const command =
+          process.platform === 'win32'
+            ? `${diffCommand.command} ${diffCommand.args.join(' ')}`
+            : `${diffCommand.command} ${diffCommand.args.map((arg) => `"${arg}"`).join(' ')}`;
+        try {
+          execSync(command, {
+            stdio: 'inherit',
+            encoding: 'utf8',
+          });
+        } catch (e) {
+          console.error('Error in onEditorClose callback:', e);
+        } finally {
+          onEditorClose();
+        }
+        break;
+      }
+
+      default:
+        throw new Error(`Unsupported editor: ${editor}`);
+    }
+  } catch (error) {
+    console.error(error);
+  }
+}

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

@@ -0,0 +1,215 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import {
+  describe,
+  it,
+  expect,
+  vi,
+  beforeEach,
+  afterEach,
+  type Mock,
+} from 'vitest';
+import {
+  getEnvironmentContext,
+  getDirectoryContextString,
+} from './environmentContext.js';
+import { Config } from '../config/config.js';
+import { getFolderStructure } from './getFolderStructure.js';
+
+vi.mock('../config/config.js');
+vi.mock('./getFolderStructure.js', () => ({
+  getFolderStructure: vi.fn(),
+}));
+vi.mock('../tools/read-many-files.js');
+
+describe('getDirectoryContextString', () => {
+  let mockConfig: Partial<Config>;
+
+  beforeEach(() => {
+    mockConfig = {
+      getWorkspaceContext: vi.fn().mockReturnValue({
+        getDirectories: vi.fn().mockReturnValue(['/test/dir']),
+      }),
+      getFileService: vi.fn(),
+    };
+    vi.mocked(getFolderStructure).mockResolvedValue('Mock Folder Structure');
+  });
+
+  afterEach(() => {
+    vi.resetAllMocks();
+  });
+
+  it('should return context string for a single directory', async () => {
+    const contextString = await getDirectoryContextString(mockConfig as Config);
+    expect(contextString).toContain(
+      "I'm currently working in the directory: /test/dir",
+    );
+    expect(contextString).toContain(
+      'Here is the folder structure of the current working directories:\n\nMock Folder Structure',
+    );
+  });
+
+  it('should return context string for multiple directories', async () => {
+    (
+      vi.mocked(mockConfig.getWorkspaceContext!)().getDirectories as Mock
+    ).mockReturnValue(['/test/dir1', '/test/dir2']);
+    vi.mocked(getFolderStructure)
+      .mockResolvedValueOnce('Structure 1')
+      .mockResolvedValueOnce('Structure 2');
+
+    const contextString = await getDirectoryContextString(mockConfig as Config);
+    expect(contextString).toContain(
+      "I'm currently working in the following directories:\n  - /test/dir1\n  - /test/dir2",
+    );
+    expect(contextString).toContain(
+      'Here is the folder structure of the current working directories:\n\nStructure 1\nStructure 2',
+    );
+  });
+});
+
+describe('getEnvironmentContext', () => {
+  let mockConfig: Partial<Config>;
+  let mockToolRegistry: { getTool: Mock };
+
+  beforeEach(() => {
+    vi.useFakeTimers();
+    vi.setSystemTime(new Date('2025-08-05T12:00:00Z'));
+
+    // Mock the locale to ensure consistent English date formatting
+    vi.stubGlobal('Intl', {
+      ...global.Intl,
+      DateTimeFormat: vi.fn().mockImplementation(() => ({
+        format: vi.fn().mockReturnValue('Tuesday, August 5, 2025'),
+      })),
+    });
+
+    mockToolRegistry = {
+      getTool: vi.fn(),
+    };
+
+    mockConfig = {
+      getWorkspaceContext: vi.fn().mockReturnValue({
+        getDirectories: vi.fn().mockReturnValue(['/test/dir']),
+      }),
+      getFileService: vi.fn(),
+      getFullContext: vi.fn().mockReturnValue(false),
+      getToolRegistry: vi.fn().mockReturnValue(mockToolRegistry),
+    };
+
+    vi.mocked(getFolderStructure).mockResolvedValue('Mock Folder Structure');
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+    vi.unstubAllGlobals();
+    vi.resetAllMocks();
+  });
+
+  it('should return basic environment context for a single directory', async () => {
+    const parts = await getEnvironmentContext(mockConfig as Config);
+
+    expect(parts.length).toBe(1);
+    const context = parts[0].text;
+
+    expect(context).toContain("Today's date is");
+    expect(context).toContain("(formatted according to the user's locale)");
+    expect(context).toContain(`My operating system is: ${process.platform}`);
+    expect(context).toContain(
+      "I'm currently working in the directory: /test/dir",
+    );
+    expect(context).toContain(
+      'Here is the folder structure of the current working directories:\n\nMock Folder Structure',
+    );
+    expect(getFolderStructure).toHaveBeenCalledWith('/test/dir', {
+      fileService: undefined,
+    });
+  });
+
+  it('should return basic environment context for multiple directories', async () => {
+    (
+      vi.mocked(mockConfig.getWorkspaceContext!)().getDirectories as Mock
+    ).mockReturnValue(['/test/dir1', '/test/dir2']);
+    vi.mocked(getFolderStructure)
+      .mockResolvedValueOnce('Structure 1')
+      .mockResolvedValueOnce('Structure 2');
+
+    const parts = await getEnvironmentContext(mockConfig as Config);
+
+    expect(parts.length).toBe(1);
+    const context = parts[0].text;
+
+    expect(context).toContain(
+      "I'm currently working in the following directories:\n  - /test/dir1\n  - /test/dir2",
+    );
+    expect(context).toContain(
+      'Here is the folder structure of the current working directories:\n\nStructure 1\nStructure 2',
+    );
+    expect(getFolderStructure).toHaveBeenCalledTimes(2);
+  });
+
+  it('should include full file context when getFullContext is true', async () => {
+    mockConfig.getFullContext = vi.fn().mockReturnValue(true);
+    const mockReadManyFilesTool = {
+      build: vi.fn().mockReturnValue({
+        execute: vi
+          .fn()
+          .mockResolvedValue({ llmContent: 'Full file content here' }),
+      }),
+    };
+    mockToolRegistry.getTool.mockReturnValue(mockReadManyFilesTool);
+
+    const parts = await getEnvironmentContext(mockConfig as Config);
+
+    expect(parts.length).toBe(2);
+    expect(parts[1].text).toBe(
+      '\n--- Full File Context ---\nFull file content here',
+    );
+    expect(mockToolRegistry.getTool).toHaveBeenCalledWith('read_many_files');
+    expect(mockReadManyFilesTool.build).toHaveBeenCalledWith({
+      paths: ['**/*'],
+      useDefaultExcludes: true,
+    });
+  });
+
+  it('should handle read_many_files returning no content', async () => {
+    mockConfig.getFullContext = vi.fn().mockReturnValue(true);
+    const mockReadManyFilesTool = {
+      build: vi.fn().mockReturnValue({
+        execute: vi.fn().mockResolvedValue({ llmContent: '' }),
+      }),
+    };
+    mockToolRegistry.getTool.mockReturnValue(mockReadManyFilesTool);
+
+    const parts = await getEnvironmentContext(mockConfig as Config);
+
+    expect(parts.length).toBe(1); // No extra part added
+  });
+
+  it('should handle read_many_files tool not being found', async () => {
+    mockConfig.getFullContext = vi.fn().mockReturnValue(true);
+    mockToolRegistry.getTool.mockReturnValue(null);
+
+    const parts = await getEnvironmentContext(mockConfig as Config);
+
+    expect(parts.length).toBe(1); // No extra part added
+  });
+
+  it('should handle errors when reading full file context', async () => {
+    mockConfig.getFullContext = vi.fn().mockReturnValue(true);
+    const mockReadManyFilesTool = {
+      build: vi.fn().mockReturnValue({
+        execute: vi.fn().mockRejectedValue(new Error('Read error')),
+      }),
+    };
+    mockToolRegistry.getTool.mockReturnValue(mockReadManyFilesTool);
+
+    const parts = await getEnvironmentContext(mockConfig as Config);
+
+    expect(parts.length).toBe(2);
+    expect(parts[1].text).toBe('\n--- Error reading full file context ---');
+  });
+});

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

@@ -0,0 +1,109 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { Part } from '@google/genai';
+import { Config } from '../config/config.js';
+import { getFolderStructure } from './getFolderStructure.js';
+
+/**
+ * Generates a string describing the current workspace directories and their structures.
+ * @param {Config} config - The runtime configuration and services.
+ * @returns {Promise<string>} A promise that resolves to the directory context string.
+ */
+export async function getDirectoryContextString(
+  config: Config,
+): Promise<string> {
+  const workspaceContext = config.getWorkspaceContext();
+  const workspaceDirectories = workspaceContext.getDirectories();
+
+  const folderStructures = await Promise.all(
+    workspaceDirectories.map((dir) =>
+      getFolderStructure(dir, {
+        fileService: config.getFileService(),
+      }),
+    ),
+  );
+
+  const folderStructure = folderStructures.join('\n');
+
+  let workingDirPreamble: string;
+  if (workspaceDirectories.length === 1) {
+    workingDirPreamble = `I'm currently working in the directory: ${workspaceDirectories[0]}`;
+  } else {
+    const dirList = workspaceDirectories.map((dir) => `  - ${dir}`).join('\n');
+    workingDirPreamble = `I'm currently working in the following directories:\n${dirList}`;
+  }
+
+  return `${workingDirPreamble}
+Here is the folder structure of the current working directories:
+
+${folderStructure}`;
+}
+
+/**
+ * Retrieves environment-related information to be included in the chat context.
+ * This includes the current working directory, date, operating system, and folder structure.
+ * Optionally, it can also include the full file context if enabled.
+ * @param {Config} config - The runtime configuration and services.
+ * @returns A promise that resolves to an array of `Part` objects containing environment information.
+ */
+export async function getEnvironmentContext(config: Config): Promise<Part[]> {
+  const today = new Date().toLocaleDateString(undefined, {
+    weekday: 'long',
+    year: 'numeric',
+    month: 'long',
+    day: 'numeric',
+  });
+  const platform = process.platform;
+  const directoryContext = await getDirectoryContextString(config);
+
+  const context = `
+This is the Qwen Code. We are setting up the context for our chat.
+Today's date is ${today} (formatted according to the user's locale).
+My operating system is: ${platform}
+${directoryContext}
+        `.trim();
+
+  const initialParts: Part[] = [{ text: context }];
+  const toolRegistry = config.getToolRegistry();
+
+  // Add full file context if the flag is set
+  if (config.getFullContext()) {
+    try {
+      const readManyFilesTool = toolRegistry.getTool('read_many_files');
+      if (readManyFilesTool) {
+        const invocation = readManyFilesTool.build({
+          paths: ['**/*'], // Read everything recursively
+          useDefaultExcludes: true, // Use default excludes
+        });
+
+        // Read all files in the target directory
+        const result = await invocation.execute(AbortSignal.timeout(30000));
+        if (result.llmContent) {
+          initialParts.push({
+            text: `\n--- Full File Context ---\n${result.llmContent}`,
+          });
+        } else {
+          console.warn(
+            'Full context requested, but read_many_files returned no content.',
+          );
+        }
+      } else {
+        console.warn(
+          'Full context requested, but read_many_files tool not found.',
+        );
+      }
+    } catch (error) {
+      // Not using reportError here as it's a startup/config phase, not a chat/generation phase error.
+      console.error('Error reading full file context:', error);
+      initialParts.push({
+        text: '\n--- Error reading full file context ---',
+      });
+    }
+  }
+
+  return initialParts;
+}

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

@@ -0,0 +1,375 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { describe, it, expect } from 'vitest';
+import { parseAndFormatApiError } from './errorParsing.js';
+import { isProQuotaExceededError } from './quotaErrorDetection.js';
+import { DEFAULT_GEMINI_FLASH_MODEL } from '../config/models.js';
+import { UserTierId } from '../code_assist/types.js';
+import { AuthType } from '../core/contentGenerator.js';
+import { StructuredError } from '../core/turn.js';
+
+describe('parseAndFormatApiError', () => {
+  const vertexMessage = 'request a quota increase through Vertex';
+  const geminiMessage = 'request a quota increase through AI Studio';
+
+  it('should format a valid API error JSON', () => {
+    const errorMessage =
+      'got status: 400 Bad Request. {"error":{"code":400,"message":"API key not valid. Please pass a valid API key.","status":"INVALID_ARGUMENT"}}';
+    const expected =
+      '[API Error: API key not valid. Please pass a valid API key. (Status: INVALID_ARGUMENT)]';
+    expect(parseAndFormatApiError(errorMessage)).toBe(expected);
+  });
+
+  it('should format a 429 API error with the default message', () => {
+    const errorMessage =
+      'got status: 429 Too Many Requests. {"error":{"code":429,"message":"Rate limit exceeded","status":"RESOURCE_EXHAUSTED"}}';
+    const result = parseAndFormatApiError(
+      errorMessage,
+      undefined,
+      undefined,
+      'gemini-2.5-pro',
+      DEFAULT_GEMINI_FLASH_MODEL,
+    );
+    expect(result).toContain('[API Error: Rate limit exceeded');
+    expect(result).toContain(
+      'Possible quota limitations in place or slow response times detected. Switching to the gemini-2.5-flash model',
+    );
+  });
+
+  it('should format a 429 API error with the personal message', () => {
+    const errorMessage =
+      'got status: 429 Too Many Requests. {"error":{"code":429,"message":"Rate limit exceeded","status":"RESOURCE_EXHAUSTED"}}';
+    const result = parseAndFormatApiError(
+      errorMessage,
+      AuthType.LOGIN_WITH_GOOGLE,
+      undefined,
+      'gemini-2.5-pro',
+      DEFAULT_GEMINI_FLASH_MODEL,
+    );
+    expect(result).toContain('[API Error: Rate limit exceeded');
+    expect(result).toContain(
+      'Possible quota limitations in place or slow response times detected. Switching to the gemini-2.5-flash model',
+    );
+  });
+
+  it('should format a 429 API error with the vertex message', () => {
+    const errorMessage =
+      'got status: 429 Too Many Requests. {"error":{"code":429,"message":"Rate limit exceeded","status":"RESOURCE_EXHAUSTED"}}';
+    const result = parseAndFormatApiError(errorMessage, AuthType.USE_VERTEX_AI);
+    expect(result).toContain('[API Error: Rate limit exceeded');
+    expect(result).toContain(vertexMessage);
+  });
+
+  it('should return the original message if it is not a JSON error', () => {
+    const errorMessage = 'This is a plain old error message';
+    expect(parseAndFormatApiError(errorMessage)).toBe(
+      `[API Error: ${errorMessage}]`,
+    );
+  });
+
+  it('should return the original message for malformed JSON', () => {
+    const errorMessage = '[Stream Error: {"error": "malformed}';
+    expect(parseAndFormatApiError(errorMessage)).toBe(
+      `[API Error: ${errorMessage}]`,
+    );
+  });
+
+  it('should handle JSON that does not match the ApiError structure', () => {
+    const errorMessage = '[Stream Error: {"not_an_error": "some other json"}]';
+    expect(parseAndFormatApiError(errorMessage)).toBe(
+      `[API Error: ${errorMessage}]`,
+    );
+  });
+
+  it('should format a nested API error', () => {
+    const nestedErrorMessage = JSON.stringify({
+      error: {
+        code: 429,
+        message:
+          "Gemini 2.5 Pro Preview doesn't have a free quota tier. For more information on this error, head to: https://ai.google.dev/gemini-api/docs/rate-limits.",
+        status: 'RESOURCE_EXHAUSTED',
+      },
+    });
+
+    const errorMessage = JSON.stringify({
+      error: {
+        code: 429,
+        message: nestedErrorMessage,
+        status: 'Too Many Requests',
+      },
+    });
+
+    const result = parseAndFormatApiError(errorMessage, AuthType.USE_GEMINI);
+    expect(result).toContain('Gemini 2.5 Pro Preview');
+    expect(result).toContain(geminiMessage);
+  });
+
+  it('should format a StructuredError', () => {
+    const error: StructuredError = {
+      message: 'A structured error occurred',
+      status: 500,
+    };
+    const expected = '[API Error: A structured error occurred]';
+    expect(parseAndFormatApiError(error)).toBe(expected);
+  });
+
+  it('should format a 429 StructuredError with the vertex message', () => {
+    const error: StructuredError = {
+      message: 'Rate limit exceeded',
+      status: 429,
+    };
+    const result = parseAndFormatApiError(error, AuthType.USE_VERTEX_AI);
+    expect(result).toContain('[API Error: Rate limit exceeded]');
+    expect(result).toContain(vertexMessage);
+  });
+
+  it('should handle an unknown error type', () => {
+    const error = 12345;
+    const expected = '[API Error: An unknown error occurred.]';
+    expect(parseAndFormatApiError(error)).toBe(expected);
+  });
+
+  it('should format a 429 API error with Pro quota exceeded message for Google auth (Free tier)', () => {
+    const errorMessage =
+      'got status: 429 Too Many Requests. {"error":{"code":429,"message":"Quota exceeded for quota metric \'Gemini 2.5 Pro Requests\' and limit \'RequestsPerDay\' of service \'generativelanguage.googleapis.com\' for consumer \'project_number:123456789\'.","status":"RESOURCE_EXHAUSTED"}}';
+    const result = parseAndFormatApiError(
+      errorMessage,
+      AuthType.LOGIN_WITH_GOOGLE,
+      undefined,
+      'gemini-2.5-pro',
+      DEFAULT_GEMINI_FLASH_MODEL,
+    );
+    expect(result).toContain(
+      "[API Error: Quota exceeded for quota metric 'Gemini 2.5 Pro Requests'",
+    );
+    expect(result).toContain(
+      'You have reached your daily gemini-2.5-pro quota limit',
+    );
+    expect(result).toContain(
+      'upgrade to a Gemini Code Assist Standard or Enterprise plan',
+    );
+  });
+
+  it('should format a regular 429 API error with standard message for Google auth', () => {
+    const errorMessage =
+      'got status: 429 Too Many Requests. {"error":{"code":429,"message":"Rate limit exceeded","status":"RESOURCE_EXHAUSTED"}}';
+    const result = parseAndFormatApiError(
+      errorMessage,
+      AuthType.LOGIN_WITH_GOOGLE,
+      undefined,
+      'gemini-2.5-pro',
+      DEFAULT_GEMINI_FLASH_MODEL,
+    );
+    expect(result).toContain('[API Error: Rate limit exceeded');
+    expect(result).toContain(
+      'Possible quota limitations in place or slow response times detected. Switching to the gemini-2.5-flash model',
+    );
+    expect(result).not.toContain(
+      'You have reached your daily gemini-2.5-pro quota limit',
+    );
+  });
+
+  it('should format a 429 API error with generic quota exceeded message for Google auth', () => {
+    const errorMessage =
+      'got status: 429 Too Many Requests. {"error":{"code":429,"message":"Quota exceeded for quota metric \'GenerationRequests\' and limit \'RequestsPerDay\' of service \'generativelanguage.googleapis.com\' for consumer \'project_number:123456789\'.","status":"RESOURCE_EXHAUSTED"}}';
+    const result = parseAndFormatApiError(
+      errorMessage,
+      AuthType.LOGIN_WITH_GOOGLE,
+      undefined,
+      'gemini-2.5-pro',
+      DEFAULT_GEMINI_FLASH_MODEL,
+    );
+    expect(result).toContain(
+      "[API Error: Quota exceeded for quota metric 'GenerationRequests'",
+    );
+    expect(result).toContain('You have reached your daily quota limit');
+    expect(result).not.toContain(
+      'You have reached your daily Gemini 2.5 Pro quota limit',
+    );
+  });
+
+  it('should prioritize Pro quota message over generic quota message for Google auth', () => {
+    const errorMessage =
+      'got status: 429 Too Many Requests. {"error":{"code":429,"message":"Quota exceeded for quota metric \'Gemini 2.5 Pro Requests\' and limit \'RequestsPerDay\' of service \'generativelanguage.googleapis.com\' for consumer \'project_number:123456789\'.","status":"RESOURCE_EXHAUSTED"}}';
+    const result = parseAndFormatApiError(
+      errorMessage,
+      AuthType.LOGIN_WITH_GOOGLE,
+      undefined,
+      'gemini-2.5-pro',
+      DEFAULT_GEMINI_FLASH_MODEL,
+    );
+    expect(result).toContain(
+      "[API Error: Quota exceeded for quota metric 'Gemini 2.5 Pro Requests'",
+    );
+    expect(result).toContain(
+      'You have reached your daily gemini-2.5-pro quota limit',
+    );
+    expect(result).not.toContain('You have reached your daily quota limit');
+  });
+
+  it('should format a 429 API error with Pro quota exceeded message for Google auth (Standard tier)', () => {
+    const errorMessage =
+      'got status: 429 Too Many Requests. {"error":{"code":429,"message":"Quota exceeded for quota metric \'Gemini 2.5 Pro Requests\' and limit \'RequestsPerDay\' of service \'generativelanguage.googleapis.com\' for consumer \'project_number:123456789\'.","status":"RESOURCE_EXHAUSTED"}}';
+    const result = parseAndFormatApiError(
+      errorMessage,
+      AuthType.LOGIN_WITH_GOOGLE,
+      UserTierId.STANDARD,
+      'gemini-2.5-pro',
+      DEFAULT_GEMINI_FLASH_MODEL,
+    );
+    expect(result).toContain(
+      "[API Error: Quota exceeded for quota metric 'Gemini 2.5 Pro Requests'",
+    );
+    expect(result).toContain(
+      'You have reached your daily gemini-2.5-pro quota limit',
+    );
+    expect(result).toContain(
+      'We appreciate you for choosing Gemini Code Assist and the Gemini CLI',
+    );
+    expect(result).not.toContain(
+      'upgrade to a Gemini Code Assist Standard or Enterprise plan',
+    );
+  });
+
+  it('should format a 429 API error with Pro quota exceeded message for Google auth (Legacy tier)', () => {
+    const errorMessage =
+      'got status: 429 Too Many Requests. {"error":{"code":429,"message":"Quota exceeded for quota metric \'Gemini 2.5 Pro Requests\' and limit \'RequestsPerDay\' of service \'generativelanguage.googleapis.com\' for consumer \'project_number:123456789\'.","status":"RESOURCE_EXHAUSTED"}}';
+    const result = parseAndFormatApiError(
+      errorMessage,
+      AuthType.LOGIN_WITH_GOOGLE,
+      UserTierId.LEGACY,
+      'gemini-2.5-pro',
+      DEFAULT_GEMINI_FLASH_MODEL,
+    );
+    expect(result).toContain(
+      "[API Error: Quota exceeded for quota metric 'Gemini 2.5 Pro Requests'",
+    );
+    expect(result).toContain(
+      'You have reached your daily gemini-2.5-pro quota limit',
+    );
+    expect(result).toContain(
+      'We appreciate you for choosing Gemini Code Assist and the Gemini CLI',
+    );
+    expect(result).not.toContain(
+      'upgrade to a Gemini Code Assist Standard or Enterprise plan',
+    );
+  });
+
+  it('should handle different Gemini 2.5 version strings in Pro quota exceeded errors', () => {
+    const errorMessage25 =
+      'got status: 429 Too Many Requests. {"error":{"code":429,"message":"Quota exceeded for quota metric \'Gemini 2.5 Pro Requests\' and limit \'RequestsPerDay\' of service \'generativelanguage.googleapis.com\' for consumer \'project_number:123456789\'.","status":"RESOURCE_EXHAUSTED"}}';
+    const errorMessagePreview =
+      'got status: 429 Too Many Requests. {"error":{"code":429,"message":"Quota exceeded for quota metric \'Gemini 2.5-preview Pro Requests\' and limit \'RequestsPerDay\' of service \'generativelanguage.googleapis.com\' for consumer \'project_number:123456789\'.","status":"RESOURCE_EXHAUSTED"}}';
+
+    const result25 = parseAndFormatApiError(
+      errorMessage25,
+      AuthType.LOGIN_WITH_GOOGLE,
+      undefined,
+      'gemini-2.5-pro',
+      DEFAULT_GEMINI_FLASH_MODEL,
+    );
+    const resultPreview = parseAndFormatApiError(
+      errorMessagePreview,
+      AuthType.LOGIN_WITH_GOOGLE,
+      undefined,
+      'gemini-2.5-preview-pro',
+      DEFAULT_GEMINI_FLASH_MODEL,
+    );
+
+    expect(result25).toContain(
+      'You have reached your daily gemini-2.5-pro quota limit',
+    );
+    expect(resultPreview).toContain(
+      'You have reached your daily gemini-2.5-preview-pro quota limit',
+    );
+    expect(result25).toContain(
+      'upgrade to a Gemini Code Assist Standard or Enterprise plan',
+    );
+    expect(resultPreview).toContain(
+      'upgrade to a Gemini Code Assist Standard or Enterprise plan',
+    );
+  });
+
+  it('should not match non-Pro models with similar version strings', () => {
+    // Test that Flash models with similar version strings don't match
+    expect(
+      isProQuotaExceededError(
+        "Quota exceeded for quota metric 'Gemini 2.5 Flash Requests' and limit",
+      ),
+    ).toBe(false);
+    expect(
+      isProQuotaExceededError(
+        "Quota exceeded for quota metric 'Gemini 2.5-preview Flash Requests' and limit",
+      ),
+    ).toBe(false);
+
+    // Test other model types
+    expect(
+      isProQuotaExceededError(
+        "Quota exceeded for quota metric 'Gemini 2.5 Ultra Requests' and limit",
+      ),
+    ).toBe(false);
+    expect(
+      isProQuotaExceededError(
+        "Quota exceeded for quota metric 'Gemini 2.5 Standard Requests' and limit",
+      ),
+    ).toBe(false);
+
+    // Test generic quota messages
+    expect(
+      isProQuotaExceededError(
+        "Quota exceeded for quota metric 'GenerationRequests' and limit",
+      ),
+    ).toBe(false);
+    expect(
+      isProQuotaExceededError(
+        "Quota exceeded for quota metric 'EmbeddingRequests' and limit",
+      ),
+    ).toBe(false);
+  });
+
+  it('should format a generic quota exceeded message for Google auth (Standard tier)', () => {
+    const errorMessage =
+      'got status: 429 Too Many Requests. {"error":{"code":429,"message":"Quota exceeded for quota metric \'GenerationRequests\' and limit \'RequestsPerDay\' of service \'generativelanguage.googleapis.com\' for consumer \'project_number:123456789\'.","status":"RESOURCE_EXHAUSTED"}}';
+    const result = parseAndFormatApiError(
+      errorMessage,
+      AuthType.LOGIN_WITH_GOOGLE,
+      UserTierId.STANDARD,
+      'gemini-2.5-pro',
+      DEFAULT_GEMINI_FLASH_MODEL,
+    );
+    expect(result).toContain(
+      "[API Error: Quota exceeded for quota metric 'GenerationRequests'",
+    );
+    expect(result).toContain('You have reached your daily quota limit');
+    expect(result).toContain(
+      'We appreciate you for choosing Gemini Code Assist and the Gemini CLI',
+    );
+    expect(result).not.toContain(
+      'upgrade to a Gemini Code Assist Standard or Enterprise plan',
+    );
+  });
+
+  it('should format a regular 429 API error with standard message for Google auth (Standard tier)', () => {
+    const errorMessage =
+      'got status: 429 Too Many Requests. {"error":{"code":429,"message":"Rate limit exceeded","status":"RESOURCE_EXHAUSTED"}}';
+    const result = parseAndFormatApiError(
+      errorMessage,
+      AuthType.LOGIN_WITH_GOOGLE,
+      UserTierId.STANDARD,
+      'gemini-2.5-pro',
+      DEFAULT_GEMINI_FLASH_MODEL,
+    );
+    expect(result).toContain('[API Error: Rate limit exceeded');
+    expect(result).toContain(
+      'We appreciate you for choosing Gemini Code Assist and the Gemini CLI',
+    );
+    expect(result).not.toContain(
+      'upgrade to a Gemini Code Assist Standard or Enterprise plan',
+    );
+  });
+});

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

@@ -0,0 +1,166 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import {
+  isProQuotaExceededError,
+  isGenericQuotaExceededError,
+  isApiError,
+  isStructuredError,
+} from './quotaErrorDetection.js';
+import {
+  DEFAULT_GEMINI_MODEL,
+  DEFAULT_GEMINI_FLASH_MODEL,
+} from '../config/models.js';
+import { UserTierId } from '../code_assist/types.js';
+import { AuthType } from '../core/contentGenerator.js';
+
+// Free Tier message functions
+const getRateLimitErrorMessageGoogleFree = (
+  fallbackModel: string = DEFAULT_GEMINI_FLASH_MODEL,
+) =>
+  `\nPossible quota limitations in place or slow response times detected. Switching to the ${fallbackModel} model for the rest of this session.`;
+
+const getRateLimitErrorMessageGoogleProQuotaFree = (
+  currentModel: string = DEFAULT_GEMINI_MODEL,
+  fallbackModel: string = DEFAULT_GEMINI_FLASH_MODEL,
+) =>
+  `\nYou have reached your daily ${currentModel} quota limit. You will be switched to the ${fallbackModel} model for the rest of this session. To increase your limits, upgrade to a Gemini Code Assist Standard or Enterprise plan with higher limits at https://goo.gle/set-up-gemini-code-assist, or use /auth to switch to using a paid API key from AI Studio at https://aistudio.google.com/apikey`;
+
+const getRateLimitErrorMessageGoogleGenericQuotaFree = () =>
+  `\nYou have reached your daily quota limit. To increase your limits, upgrade to a Gemini Code Assist Standard or Enterprise plan with higher limits at https://goo.gle/set-up-gemini-code-assist, or use /auth to switch to using a paid API key from AI Studio at https://aistudio.google.com/apikey`;
+
+// Legacy/Standard Tier message functions
+const getRateLimitErrorMessageGooglePaid = (
+  fallbackModel: string = DEFAULT_GEMINI_FLASH_MODEL,
+) =>
+  `\nPossible quota limitations in place or slow response times detected. Switching to the ${fallbackModel} model for the rest of this session. We appreciate you for choosing Gemini Code Assist and the Gemini CLI.`;
+
+const getRateLimitErrorMessageGoogleProQuotaPaid = (
+  currentModel: string = DEFAULT_GEMINI_MODEL,
+  fallbackModel: string = DEFAULT_GEMINI_FLASH_MODEL,
+) =>
+  `\nYou have reached your daily ${currentModel} quota limit. You will be switched to the ${fallbackModel} model for the rest of this session. We appreciate you for choosing Gemini Code Assist and the Gemini CLI. To continue accessing the ${currentModel} model today, consider using /auth to switch to using a paid API key from AI Studio at https://aistudio.google.com/apikey`;
+
+const getRateLimitErrorMessageGoogleGenericQuotaPaid = (
+  currentModel: string = DEFAULT_GEMINI_MODEL,
+) =>
+  `\nYou have reached your daily quota limit. We appreciate you for choosing Gemini Code Assist and the Gemini CLI. To continue accessing the ${currentModel} model today, consider using /auth to switch to using a paid API key from AI Studio at https://aistudio.google.com/apikey`;
+const RATE_LIMIT_ERROR_MESSAGE_USE_GEMINI =
+  '\nPlease wait and try again later. To increase your limits, request a quota increase through AI Studio, or switch to another /auth method';
+const RATE_LIMIT_ERROR_MESSAGE_VERTEX =
+  '\nPlease wait and try again later. To increase your limits, request a quota increase through Vertex, or switch to another /auth method';
+const getRateLimitErrorMessageDefault = (
+  fallbackModel: string = DEFAULT_GEMINI_FLASH_MODEL,
+) =>
+  `\nPossible quota limitations in place or slow response times detected. Switching to the ${fallbackModel} model for the rest of this session.`;
+
+function getRateLimitMessage(
+  authType?: AuthType,
+  error?: unknown,
+  userTier?: UserTierId,
+  currentModel?: string,
+  fallbackModel?: string,
+): string {
+  switch (authType) {
+    case AuthType.LOGIN_WITH_GOOGLE: {
+      // Determine if user is on a paid tier (Legacy or Standard) - default to FREE if not specified
+      const isPaidTier =
+        userTier === UserTierId.LEGACY || userTier === UserTierId.STANDARD;
+
+      if (isProQuotaExceededError(error)) {
+        return isPaidTier
+          ? getRateLimitErrorMessageGoogleProQuotaPaid(
+              currentModel || DEFAULT_GEMINI_MODEL,
+              fallbackModel,
+            )
+          : getRateLimitErrorMessageGoogleProQuotaFree(
+              currentModel || DEFAULT_GEMINI_MODEL,
+              fallbackModel,
+            );
+      } else if (isGenericQuotaExceededError(error)) {
+        return isPaidTier
+          ? getRateLimitErrorMessageGoogleGenericQuotaPaid(
+              currentModel || DEFAULT_GEMINI_MODEL,
+            )
+          : getRateLimitErrorMessageGoogleGenericQuotaFree();
+      } else {
+        return isPaidTier
+          ? getRateLimitErrorMessageGooglePaid(fallbackModel)
+          : getRateLimitErrorMessageGoogleFree(fallbackModel);
+      }
+    }
+    case AuthType.USE_GEMINI:
+      return RATE_LIMIT_ERROR_MESSAGE_USE_GEMINI;
+    case AuthType.USE_VERTEX_AI:
+      return RATE_LIMIT_ERROR_MESSAGE_VERTEX;
+    default:
+      return getRateLimitErrorMessageDefault(fallbackModel);
+  }
+}
+
+export function parseAndFormatApiError(
+  error: unknown,
+  authType?: AuthType,
+  userTier?: UserTierId,
+  currentModel?: string,
+  fallbackModel?: string,
+): string {
+  if (isStructuredError(error)) {
+    let text = `[API Error: ${error.message}]`;
+    if (error.status === 429) {
+      text += getRateLimitMessage(
+        authType,
+        error,
+        userTier,
+        currentModel,
+        fallbackModel,
+      );
+    }
+    return text;
+  }
+
+  // The error message might be a string containing a JSON object.
+  if (typeof error === 'string') {
+    const jsonStart = error.indexOf('{');
+    if (jsonStart === -1) {
+      return `[API Error: ${error}]`; // Not a JSON error, return as is.
+    }
+
+    const jsonString = error.substring(jsonStart);
+
+    try {
+      const parsedError = JSON.parse(jsonString) as unknown;
+      if (isApiError(parsedError)) {
+        let finalMessage = parsedError.error.message;
+        try {
+          // See if the message is a stringified JSON with another error
+          const nestedError = JSON.parse(finalMessage) as unknown;
+          if (isApiError(nestedError)) {
+            finalMessage = nestedError.error.message;
+          }
+        } catch (_e) {
+          // It's not a nested JSON error, so we just use the message as is.
+        }
+        let text = `[API Error: ${finalMessage} (Status: ${parsedError.error.status})]`;
+        if (parsedError.error.code === 429) {
+          text += getRateLimitMessage(
+            authType,
+            parsedError,
+            userTier,
+            currentModel,
+            fallbackModel,
+          );
+        }
+        return text;
+      }
+    } catch (_e) {
+      // Not a valid JSON, fall through and return the original message.
+    }
+    return `[API Error: ${error}]`;
+  }
+
+  return '[API Error: An unknown error occurred.]';
+}

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

@@ -0,0 +1,193 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { reportError } from './errorReporting.js';
+
+// Use a type alias for SpyInstance as it's not directly exported
+type SpyInstance = ReturnType<typeof vi.spyOn>;
+
+describe('reportError', () => {
+  let consoleErrorSpy: SpyInstance;
+  let testDir: string;
+  const MOCK_TIMESTAMP = '2025-01-01T00-00-00-000Z';
+
+  beforeEach(async () => {
+    // Create a temporary directory for logs
+    testDir = await fs.mkdtemp(path.join(os.tmpdir(), 'gemini-report-test-'));
+    vi.resetAllMocks();
+    consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+    vi.spyOn(Date.prototype, 'toISOString').mockReturnValue(MOCK_TIMESTAMP);
+  });
+
+  afterEach(async () => {
+    vi.restoreAllMocks();
+    // Clean up the temporary directory
+    await fs.rm(testDir, { recursive: true, force: true });
+  });
+
+  const getExpectedReportPath = (type: string) =>
+    path.join(testDir, `gemini-client-error-${type}-${MOCK_TIMESTAMP}.json`);
+
+  it('should generate a report and log the path', async () => {
+    const error = new Error('Test error');
+    error.stack = 'Test stack';
+    const baseMessage = 'An error occurred.';
+    const context = { data: 'test context' };
+    const type = 'test-type';
+    const expectedReportPath = getExpectedReportPath(type);
+
+    await reportError(error, baseMessage, context, type, testDir);
+
+    // Verify the file was written
+    const reportContent = await fs.readFile(expectedReportPath, 'utf-8');
+    const parsedReport = JSON.parse(reportContent);
+
+    expect(parsedReport).toEqual({
+      error: { message: 'Test error', stack: 'Test stack' },
+      context,
+    });
+
+    // Verify the console log
+    expect(consoleErrorSpy).toHaveBeenCalledWith(
+      `${baseMessage} Full report available at: ${expectedReportPath}`,
+    );
+  });
+
+  it('should handle errors that are plain objects with a message property', async () => {
+    const error = { message: 'Test plain object error' };
+    const baseMessage = 'Another error.';
+    const type = 'general';
+    const expectedReportPath = getExpectedReportPath(type);
+
+    await reportError(error, baseMessage, undefined, type, testDir);
+
+    const reportContent = await fs.readFile(expectedReportPath, 'utf-8');
+    const parsedReport = JSON.parse(reportContent);
+
+    expect(parsedReport).toEqual({
+      error: { message: 'Test plain object error' },
+    });
+
+    expect(consoleErrorSpy).toHaveBeenCalledWith(
+      `${baseMessage} Full report available at: ${expectedReportPath}`,
+    );
+  });
+
+  it('should handle string errors', async () => {
+    const error = 'Just a string error';
+    const baseMessage = 'String error occurred.';
+    const type = 'general';
+    const expectedReportPath = getExpectedReportPath(type);
+
+    await reportError(error, baseMessage, undefined, type, testDir);
+
+    const reportContent = await fs.readFile(expectedReportPath, 'utf-8');
+    const parsedReport = JSON.parse(reportContent);
+
+    expect(parsedReport).toEqual({
+      error: { message: 'Just a string error' },
+    });
+
+    expect(consoleErrorSpy).toHaveBeenCalledWith(
+      `${baseMessage} Full report available at: ${expectedReportPath}`,
+    );
+  });
+
+  it('should log fallback message if writing report fails', async () => {
+    const error = new Error('Main error');
+    const baseMessage = 'Failed operation.';
+    const context = ['some context'];
+    const type = 'general';
+    const nonExistentDir = path.join(testDir, 'non-existent-dir');
+
+    await reportError(error, baseMessage, context, type, nonExistentDir);
+
+    expect(consoleErrorSpy).toHaveBeenCalledWith(
+      `${baseMessage} Additionally, failed to write detailed error report:`,
+      expect.any(Error), // The actual write error
+    );
+    expect(consoleErrorSpy).toHaveBeenCalledWith(
+      'Original error that triggered report generation:',
+      error,
+    );
+    expect(consoleErrorSpy).toHaveBeenCalledWith('Original context:', context);
+  });
+
+  it('should handle stringification failure of report content (e.g. BigInt in context)', async () => {
+    const error = new Error('Main error');
+    error.stack = 'Main stack';
+    const baseMessage = 'Failed operation with BigInt.';
+    const context = { a: BigInt(1) }; // BigInt cannot be stringified by JSON.stringify
+    const type = 'bigint-fail';
+    const stringifyError = new TypeError(
+      'Do not know how to serialize a BigInt',
+    );
+    const expectedMinimalReportPath = getExpectedReportPath(type);
+
+    // Simulate JSON.stringify throwing an error for the full report
+    const originalJsonStringify = JSON.stringify;
+    let callCount = 0;
+    vi.spyOn(JSON, 'stringify').mockImplementation((value, replacer, space) => {
+      callCount++;
+      if (callCount === 1) {
+        // First call is for the full report content
+        throw stringifyError;
+      }
+      // Subsequent calls (for minimal report) should succeed
+      return originalJsonStringify(value, replacer, space);
+    });
+
+    await reportError(error, baseMessage, context, type, testDir);
+
+    expect(consoleErrorSpy).toHaveBeenCalledWith(
+      `${baseMessage} Could not stringify report content (likely due to context):`,
+      stringifyError,
+    );
+    expect(consoleErrorSpy).toHaveBeenCalledWith(
+      'Original error that triggered report generation:',
+      error,
+    );
+    expect(consoleErrorSpy).toHaveBeenCalledWith(
+      'Original context could not be stringified or included in report.',
+    );
+
+    // Check that it writes a minimal report
+    const reportContent = await fs.readFile(expectedMinimalReportPath, 'utf-8');
+    const parsedReport = JSON.parse(reportContent);
+    expect(parsedReport).toEqual({
+      error: { message: error.message, stack: error.stack },
+    });
+
+    expect(consoleErrorSpy).toHaveBeenCalledWith(
+      `${baseMessage} Partial report (excluding context) available at: ${expectedMinimalReportPath}`,
+    );
+  });
+
+  it('should generate a report without context if context is not provided', async () => {
+    const error = new Error('Error without context');
+    error.stack = 'No context stack';
+    const baseMessage = 'Simple error.';
+    const type = 'general';
+    const expectedReportPath = getExpectedReportPath(type);
+
+    await reportError(error, baseMessage, undefined, type, testDir);
+
+    const reportContent = await fs.readFile(expectedReportPath, 'utf-8');
+    const parsedReport = JSON.parse(reportContent);
+
+    expect(parsedReport).toEqual({
+      error: { message: 'Error without context', stack: 'No context stack' },
+    });
+
+    expect(consoleErrorSpy).toHaveBeenCalledWith(
+      `${baseMessage} Full report available at: ${expectedReportPath}`,
+    );
+  });
+});

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

@@ -0,0 +1,118 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { Content } from '@google/genai';
+
+interface ErrorReportData {
+  error: { message: string; stack?: string } | { message: string };
+  context?: unknown;
+  additionalInfo?: Record<string, unknown>;
+}
+
+/**
+ * Generates an error report, writes it to a temporary file, and logs information to console.error.
+ * @param error The error object.
+ * @param context The relevant context (e.g., chat history, request contents).
+ * @param type A string to identify the type of error (e.g., 'startChat', 'generateJson-api').
+ * @param baseMessage The initial message to log to console.error before the report path.
+ */
+export async function reportError(
+  error: Error | unknown,
+  baseMessage: string,
+  context?: Content[] | Record<string, unknown> | unknown[],
+  type = 'general',
+  reportingDir = os.tmpdir(), // for testing
+): Promise<void> {
+  const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+  const reportFileName = `gemini-client-error-${type}-${timestamp}.json`;
+  const reportPath = path.join(reportingDir, reportFileName);
+
+  let errorToReport: { message: string; stack?: string };
+  if (error instanceof Error) {
+    errorToReport = { message: error.message, stack: error.stack };
+  } else if (
+    typeof error === 'object' &&
+    error !== null &&
+    'message' in error
+  ) {
+    errorToReport = {
+      message: String((error as { message: unknown }).message),
+    };
+  } else {
+    errorToReport = { message: String(error) };
+  }
+
+  const reportContent: ErrorReportData = { error: errorToReport };
+
+  if (context) {
+    reportContent.context = context;
+  }
+
+  let stringifiedReportContent: string;
+  try {
+    stringifiedReportContent = JSON.stringify(reportContent, null, 2);
+  } catch (stringifyError) {
+    // This can happen if context contains something like BigInt
+    console.error(
+      `${baseMessage} Could not stringify report content (likely due to context):`,
+      stringifyError,
+    );
+    console.error('Original error that triggered report generation:', error);
+    if (context) {
+      console.error(
+        'Original context could not be stringified or included in report.',
+      );
+    }
+    // Fallback: try to report only the error if context was the issue
+    try {
+      const minimalReportContent = { error: errorToReport };
+      stringifiedReportContent = JSON.stringify(minimalReportContent, null, 2);
+      // Still try to write the minimal report
+      await fs.writeFile(reportPath, stringifiedReportContent);
+      console.error(
+        `${baseMessage} Partial report (excluding context) available at: ${reportPath}`,
+      );
+    } catch (minimalWriteError) {
+      console.error(
+        `${baseMessage} Failed to write even a minimal error report:`,
+        minimalWriteError,
+      );
+    }
+    return;
+  }
+
+  try {
+    await fs.writeFile(reportPath, stringifiedReportContent);
+    console.error(`${baseMessage} Full report available at: ${reportPath}`);
+  } catch (writeError) {
+    console.error(
+      `${baseMessage} Additionally, failed to write detailed error report:`,
+      writeError,
+    );
+    // Log the original error as a fallback if report writing fails
+    console.error('Original error that triggered report generation:', error);
+    if (context) {
+      // Context was stringifiable, but writing the file failed.
+      // We already have stringifiedReportContent, but it might be too large for console.
+      // So, we try to log the original context object, and if that fails, its stringified version (truncated).
+      try {
+        console.error('Original context:', context);
+      } catch {
+        try {
+          console.error(
+            'Original context (stringified, truncated):',
+            JSON.stringify(context).substring(0, 1000),
+          );
+        } catch {
+          console.error('Original context could not be logged or stringified.');
+        }
+      }
+    }
+  }
+}

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

@@ -0,0 +1,67 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+interface GaxiosError {
+  response?: {
+    data?: unknown;
+  };
+}
+
+export function isNodeError(error: unknown): error is NodeJS.ErrnoException {
+  return error instanceof Error && 'code' in error;
+}
+
+export function getErrorMessage(error: unknown): string {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  try {
+    return String(error);
+  } catch {
+    return 'Failed to get error details';
+  }
+}
+
+export class ForbiddenError extends Error {}
+export class UnauthorizedError extends Error {}
+export class BadRequestError extends Error {}
+
+interface ResponseData {
+  error?: {
+    code?: number;
+    message?: string;
+  };
+}
+
+export function toFriendlyError(error: unknown): unknown {
+  if (error && typeof error === 'object' && 'response' in error) {
+    const gaxiosError = error as GaxiosError;
+    const data = parseResponseData(gaxiosError);
+    if (data.error && data.error.message && data.error.code) {
+      switch (data.error.code) {
+        case 400:
+          return new BadRequestError(data.error.message);
+        case 401:
+          return new UnauthorizedError(data.error.message);
+        case 403:
+          // It's import to pass the message here since it might
+          // explain the cause like "the cloud project you're
+          // using doesn't have code assist enabled".
+          return new ForbiddenError(data.error.message);
+        default:
+      }
+    }
+  }
+  return error;
+}
+
+function parseResponseData(error: GaxiosError): ResponseData {
+  // Inexplicably, Gaxios sometimes doesn't JSONify the response data.
+  if (typeof error.response?.data === 'string') {
+    return JSON.parse(error.response?.data) as ResponseData;
+  }
+  return error.response?.data as ResponseData;
+}

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

@@ -0,0 +1,57 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { getErrorMessage, isNodeError } from './errors.js';
+import { URL } from 'url';
+
+const PRIVATE_IP_RANGES = [
+  /^10\./,
+  /^127\./,
+  /^172\.(1[6-9]|2[0-9]|3[0-1])\./,
+  /^192\.168\./,
+  /^::1$/,
+  /^fc00:/,
+  /^fe80:/,
+];
+
+export class FetchError extends Error {
+  constructor(
+    message: string,
+    public code?: string,
+  ) {
+    super(message);
+    this.name = 'FetchError';
+  }
+}
+
+export function isPrivateIp(url: string): boolean {
+  try {
+    const hostname = new URL(url).hostname;
+    return PRIVATE_IP_RANGES.some((range) => range.test(hostname));
+  } catch (_e) {
+    return false;
+  }
+}
+
+export async function fetchWithTimeout(
+  url: string,
+  timeout: number,
+): Promise<Response> {
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), timeout);
+
+  try {
+    const response = await fetch(url, { signal: controller.signal });
+    return response;
+  } catch (error) {
+    if (isNodeError(error) && error.code === 'ABORT_ERR') {
+      throw new FetchError(`Request timed out after ${timeout}ms`, 'ETIMEDOUT');
+    }
+    throw new FetchError(getErrorMessage(error));
+  } finally {
+    clearTimeout(timeoutId);
+  }
+}

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

@@ -0,0 +1,591 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import {
+  describe,
+  it,
+  expect,
+  vi,
+  beforeEach,
+  afterEach,
+  type Mock,
+} from 'vitest';
+
+import * as actualNodeFs from 'node:fs'; // For setup/teardown
+import fsPromises from 'node:fs/promises';
+import path from 'node:path';
+import os from 'node:os';
+import mime from 'mime-types';
+
+import {
+  isWithinRoot,
+  isBinaryFile,
+  detectFileType,
+  processSingleFileContent,
+} from './fileUtils.js';
+import { StandardFileSystemService } from '../services/fileSystemService.js';
+
+vi.mock('mime-types', () => ({
+  default: { lookup: vi.fn() },
+  lookup: vi.fn(),
+}));
+
+const mockMimeLookup = mime.lookup as Mock;
+
+describe('fileUtils', () => {
+  let tempRootDir: string;
+  const originalProcessCwd = process.cwd;
+
+  let testTextFilePath: string;
+  let testImageFilePath: string;
+  let testPdfFilePath: string;
+  let testBinaryFilePath: string;
+  let nonexistentFilePath: string;
+  let directoryPath: string;
+
+  beforeEach(() => {
+    vi.resetAllMocks(); // Reset all mocks, including mime.lookup
+
+    tempRootDir = actualNodeFs.mkdtempSync(
+      path.join(os.tmpdir(), 'fileUtils-test-'),
+    );
+    process.cwd = vi.fn(() => tempRootDir); // Mock cwd if necessary for relative path logic within tests
+
+    testTextFilePath = path.join(tempRootDir, 'test.txt');
+    testImageFilePath = path.join(tempRootDir, 'image.png');
+    testPdfFilePath = path.join(tempRootDir, 'document.pdf');
+    testBinaryFilePath = path.join(tempRootDir, 'app.exe');
+    nonexistentFilePath = path.join(tempRootDir, 'nonexistent.txt');
+    directoryPath = path.join(tempRootDir, 'subdir');
+
+    actualNodeFs.mkdirSync(directoryPath, { recursive: true }); // Ensure subdir exists
+  });
+
+  afterEach(() => {
+    if (actualNodeFs.existsSync(tempRootDir)) {
+      actualNodeFs.rmSync(tempRootDir, { recursive: true, force: true });
+    }
+    process.cwd = originalProcessCwd;
+    vi.restoreAllMocks(); // Restore any spies
+  });
+
+  describe('isWithinRoot', () => {
+    const root = path.resolve('/project/root');
+
+    it('should return true for paths directly within the root', () => {
+      expect(isWithinRoot(path.join(root, 'file.txt'), root)).toBe(true);
+      expect(isWithinRoot(path.join(root, 'subdir', 'file.txt'), root)).toBe(
+        true,
+      );
+    });
+
+    it('should return true for the root path itself', () => {
+      expect(isWithinRoot(root, root)).toBe(true);
+    });
+
+    it('should return false for paths outside the root', () => {
+      expect(
+        isWithinRoot(path.resolve('/project/other', 'file.txt'), root),
+      ).toBe(false);
+      expect(isWithinRoot(path.resolve('/unrelated', 'file.txt'), root)).toBe(
+        false,
+      );
+    });
+
+    it('should return false for paths that only partially match the root prefix', () => {
+      expect(
+        isWithinRoot(
+          path.resolve('/project/root-but-actually-different'),
+          root,
+        ),
+      ).toBe(false);
+    });
+
+    it('should handle paths with trailing slashes correctly', () => {
+      expect(isWithinRoot(path.join(root, 'file.txt') + path.sep, root)).toBe(
+        true,
+      );
+      expect(isWithinRoot(root + path.sep, root)).toBe(true);
+    });
+
+    it('should handle different path separators (POSIX vs Windows)', () => {
+      const posixRoot = '/project/root';
+      const posixPathInside = '/project/root/file.txt';
+      const posixPathOutside = '/project/other/file.txt';
+      expect(isWithinRoot(posixPathInside, posixRoot)).toBe(true);
+      expect(isWithinRoot(posixPathOutside, posixRoot)).toBe(false);
+    });
+
+    it('should return false for a root path that is a sub-path of the path to check', () => {
+      const pathToCheck = path.resolve('/project/root/sub');
+      const rootSub = path.resolve('/project/root');
+      expect(isWithinRoot(pathToCheck, rootSub)).toBe(true);
+
+      const pathToCheckSuper = path.resolve('/project/root');
+      const rootSuper = path.resolve('/project/root/sub');
+      expect(isWithinRoot(pathToCheckSuper, rootSuper)).toBe(false);
+    });
+  });
+
+  describe('isBinaryFile', () => {
+    let filePathForBinaryTest: string;
+
+    beforeEach(() => {
+      filePathForBinaryTest = path.join(tempRootDir, 'binaryCheck.tmp');
+    });
+
+    afterEach(() => {
+      if (actualNodeFs.existsSync(filePathForBinaryTest)) {
+        actualNodeFs.unlinkSync(filePathForBinaryTest);
+      }
+    });
+
+    it('should return false for an empty file', async () => {
+      actualNodeFs.writeFileSync(filePathForBinaryTest, '');
+      expect(await isBinaryFile(filePathForBinaryTest)).toBe(false);
+    });
+
+    it('should return false for a typical text file', async () => {
+      actualNodeFs.writeFileSync(
+        filePathForBinaryTest,
+        'Hello, world!\nThis is a test file with normal text content.',
+      );
+      expect(await isBinaryFile(filePathForBinaryTest)).toBe(false);
+    });
+
+    it('should return true for a file with many null bytes', async () => {
+      const binaryContent = Buffer.from([
+        0x48, 0x65, 0x00, 0x6c, 0x6f, 0x00, 0x00, 0x00, 0x00, 0x00,
+      ]); // "He\0llo\0\0\0\0\0"
+      actualNodeFs.writeFileSync(filePathForBinaryTest, binaryContent);
+      expect(await isBinaryFile(filePathForBinaryTest)).toBe(true);
+    });
+
+    it('should return true for a file with high percentage of non-printable ASCII', async () => {
+      const binaryContent = Buffer.from([
+        0x41, 0x42, 0x01, 0x02, 0x03, 0x04, 0x05, 0x43, 0x44, 0x06,
+      ]); // AB\x01\x02\x03\x04\x05CD\x06
+      actualNodeFs.writeFileSync(filePathForBinaryTest, binaryContent);
+      expect(await isBinaryFile(filePathForBinaryTest)).toBe(true);
+    });
+
+    it('should return false if file access fails (e.g., ENOENT)', async () => {
+      // Ensure the file does not exist
+      if (actualNodeFs.existsSync(filePathForBinaryTest)) {
+        actualNodeFs.unlinkSync(filePathForBinaryTest);
+      }
+      expect(await isBinaryFile(filePathForBinaryTest)).toBe(false);
+    });
+  });
+
+  describe('detectFileType', () => {
+    let filePathForDetectTest: string;
+
+    beforeEach(() => {
+      filePathForDetectTest = path.join(tempRootDir, 'detectType.tmp');
+      // Default: create as a text file for isBinaryFile fallback
+      actualNodeFs.writeFileSync(filePathForDetectTest, 'Plain text content');
+    });
+
+    afterEach(() => {
+      if (actualNodeFs.existsSync(filePathForDetectTest)) {
+        actualNodeFs.unlinkSync(filePathForDetectTest);
+      }
+      vi.restoreAllMocks(); // Restore spies on actualNodeFs
+    });
+
+    it('should detect typescript type by extension (ts, mts, cts, tsx)', async () => {
+      expect(await detectFileType('file.ts')).toBe('text');
+      expect(await detectFileType('file.test.ts')).toBe('text');
+      expect(await detectFileType('file.mts')).toBe('text');
+      expect(await detectFileType('vite.config.mts')).toBe('text');
+      expect(await detectFileType('file.cts')).toBe('text');
+      expect(await detectFileType('component.tsx')).toBe('text');
+    });
+
+    it('should detect image type by extension (png)', async () => {
+      mockMimeLookup.mockReturnValueOnce('image/png');
+      expect(await detectFileType('file.png')).toBe('image');
+    });
+
+    it('should detect image type by extension (jpeg)', async () => {
+      mockMimeLookup.mockReturnValueOnce('image/jpeg');
+      expect(await detectFileType('file.jpg')).toBe('image');
+    });
+
+    it('should detect svg type by extension', async () => {
+      expect(await detectFileType('image.svg')).toBe('svg');
+      expect(await detectFileType('image.icon.svg')).toBe('svg');
+    });
+
+    it('should detect pdf type by extension', async () => {
+      mockMimeLookup.mockReturnValueOnce('application/pdf');
+      expect(await detectFileType('file.pdf')).toBe('pdf');
+    });
+
+    it('should detect audio type by extension', async () => {
+      mockMimeLookup.mockReturnValueOnce('audio/mpeg');
+      expect(await detectFileType('song.mp3')).toBe('audio');
+    });
+
+    it('should detect video type by extension', async () => {
+      mockMimeLookup.mockReturnValueOnce('video/mp4');
+      expect(await detectFileType('movie.mp4')).toBe('video');
+    });
+
+    it('should detect known binary extensions as binary (e.g. .zip)', async () => {
+      mockMimeLookup.mockReturnValueOnce('application/zip');
+      expect(await detectFileType('archive.zip')).toBe('binary');
+    });
+    it('should detect known binary extensions as binary (e.g. .exe)', async () => {
+      mockMimeLookup.mockReturnValueOnce('application/octet-stream'); // Common for .exe
+      expect(await detectFileType('app.exe')).toBe('binary');
+    });
+
+    it('should use isBinaryFile for unknown extensions and detect as binary', async () => {
+      mockMimeLookup.mockReturnValueOnce(false); // Unknown mime type
+      // Create a file that isBinaryFile will identify as binary
+      const binaryContent = Buffer.from([
+        0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a,
+      ]);
+      actualNodeFs.writeFileSync(filePathForDetectTest, binaryContent);
+      expect(await detectFileType(filePathForDetectTest)).toBe('binary');
+    });
+
+    it('should default to text if mime type is unknown and content is not binary', async () => {
+      mockMimeLookup.mockReturnValueOnce(false); // Unknown mime type
+      // filePathForDetectTest is already a text file by default from beforeEach
+      expect(await detectFileType(filePathForDetectTest)).toBe('text');
+    });
+  });
+
+  describe('processSingleFileContent', () => {
+    beforeEach(() => {
+      // Ensure files exist for statSync checks before readFile might be mocked
+      if (actualNodeFs.existsSync(testTextFilePath))
+        actualNodeFs.unlinkSync(testTextFilePath);
+      if (actualNodeFs.existsSync(testImageFilePath))
+        actualNodeFs.unlinkSync(testImageFilePath);
+      if (actualNodeFs.existsSync(testPdfFilePath))
+        actualNodeFs.unlinkSync(testPdfFilePath);
+      if (actualNodeFs.existsSync(testBinaryFilePath))
+        actualNodeFs.unlinkSync(testBinaryFilePath);
+    });
+
+    it('should read a text file successfully', async () => {
+      const content = 'Line 1\\nLine 2\\nLine 3';
+      actualNodeFs.writeFileSync(testTextFilePath, content);
+      const result = await processSingleFileContent(
+        testTextFilePath,
+        tempRootDir,
+        new StandardFileSystemService(),
+      );
+      expect(result.llmContent).toBe(content);
+      expect(result.returnDisplay).toBe('');
+      expect(result.error).toBeUndefined();
+    });
+
+    it('should handle file not found', async () => {
+      const result = await processSingleFileContent(
+        nonexistentFilePath,
+        tempRootDir,
+        new StandardFileSystemService(),
+      );
+      expect(result.error).toContain('File not found');
+      expect(result.returnDisplay).toContain('File not found');
+    });
+
+    it('should handle read errors for text files', async () => {
+      actualNodeFs.writeFileSync(testTextFilePath, 'content'); // File must exist for initial statSync
+      const readError = new Error('Simulated read error');
+      vi.spyOn(fsPromises, 'readFile').mockRejectedValueOnce(readError);
+
+      const result = await processSingleFileContent(
+        testTextFilePath,
+        tempRootDir,
+        new StandardFileSystemService(),
+      );
+      expect(result.error).toContain('Simulated read error');
+      expect(result.returnDisplay).toContain('Simulated read error');
+    });
+
+    it('should handle read errors for image/pdf files', async () => {
+      actualNodeFs.writeFileSync(testImageFilePath, 'content'); // File must exist
+      mockMimeLookup.mockReturnValue('image/png');
+      const readError = new Error('Simulated image read error');
+      vi.spyOn(fsPromises, 'readFile').mockRejectedValueOnce(readError);
+
+      const result = await processSingleFileContent(
+        testImageFilePath,
+        tempRootDir,
+        new StandardFileSystemService(),
+      );
+      expect(result.error).toContain('Simulated image read error');
+      expect(result.returnDisplay).toContain('Simulated image read error');
+    });
+
+    it('should process an image file', async () => {
+      const fakePngData = Buffer.from('fake png data');
+      actualNodeFs.writeFileSync(testImageFilePath, fakePngData);
+      mockMimeLookup.mockReturnValue('image/png');
+      const result = await processSingleFileContent(
+        testImageFilePath,
+        tempRootDir,
+        new StandardFileSystemService(),
+      );
+      expect(
+        (result.llmContent as { inlineData: unknown }).inlineData,
+      ).toBeDefined();
+      expect(
+        (result.llmContent as { inlineData: { mimeType: string } }).inlineData
+          .mimeType,
+      ).toBe('image/png');
+      expect(
+        (result.llmContent as { inlineData: { data: string } }).inlineData.data,
+      ).toBe(fakePngData.toString('base64'));
+      expect(result.returnDisplay).toContain('Read image file: image.png');
+    });
+
+    it('should process a PDF file', async () => {
+      const fakePdfData = Buffer.from('fake pdf data');
+      actualNodeFs.writeFileSync(testPdfFilePath, fakePdfData);
+      mockMimeLookup.mockReturnValue('application/pdf');
+      const result = await processSingleFileContent(
+        testPdfFilePath,
+        tempRootDir,
+        new StandardFileSystemService(),
+      );
+      expect(
+        (result.llmContent as { inlineData: unknown }).inlineData,
+      ).toBeDefined();
+      expect(
+        (result.llmContent as { inlineData: { mimeType: string } }).inlineData
+          .mimeType,
+      ).toBe('application/pdf');
+      expect(
+        (result.llmContent as { inlineData: { data: string } }).inlineData.data,
+      ).toBe(fakePdfData.toString('base64'));
+      expect(result.returnDisplay).toContain('Read pdf file: document.pdf');
+    });
+
+    it('should read an SVG file as text when under 1MB', async () => {
+      const svgContent = `
+    <svg xmlns="http://www.w3.org/2000/svg" width="100" height="100">
+      <rect width="100" height="100" fill="blue" />
+    </svg>
+  `;
+      const testSvgFilePath = path.join(tempRootDir, 'test.svg');
+      actualNodeFs.writeFileSync(testSvgFilePath, svgContent, 'utf-8');
+
+      mockMimeLookup.mockReturnValue('image/svg+xml');
+
+      const result = await processSingleFileContent(
+        testSvgFilePath,
+        tempRootDir,
+        new StandardFileSystemService(),
+      );
+
+      expect(result.llmContent).toBe(svgContent);
+      expect(result.returnDisplay).toContain('Read SVG as text');
+    });
+
+    it('should skip binary files', async () => {
+      actualNodeFs.writeFileSync(
+        testBinaryFilePath,
+        Buffer.from([0x00, 0x01, 0x02]),
+      );
+      mockMimeLookup.mockReturnValueOnce('application/octet-stream');
+      // isBinaryFile will operate on the real file.
+
+      const result = await processSingleFileContent(
+        testBinaryFilePath,
+        tempRootDir,
+        new StandardFileSystemService(),
+      );
+      expect(result.llmContent).toContain(
+        'Cannot display content of binary file',
+      );
+      expect(result.returnDisplay).toContain('Skipped binary file: app.exe');
+    });
+
+    it('should handle path being a directory', async () => {
+      const result = await processSingleFileContent(
+        directoryPath,
+        tempRootDir,
+        new StandardFileSystemService(),
+      );
+      expect(result.error).toContain('Path is a directory');
+      expect(result.returnDisplay).toContain('Path is a directory');
+    });
+
+    it('should paginate text files correctly (offset and limit)', async () => {
+      const lines = Array.from({ length: 20 }, (_, i) => `Line ${i + 1}`);
+      actualNodeFs.writeFileSync(testTextFilePath, lines.join('\n'));
+
+      const result = await processSingleFileContent(
+        testTextFilePath,
+        tempRootDir,
+        new StandardFileSystemService(),
+        5,
+        5,
+      ); // Read lines 6-10
+      const expectedContent = lines.slice(5, 10).join('\n');
+
+      expect(result.llmContent).toBe(expectedContent);
+      expect(result.returnDisplay).toBe('Read lines 6-10 of 20 from test.txt');
+      expect(result.isTruncated).toBe(true);
+      expect(result.originalLineCount).toBe(20);
+      expect(result.linesShown).toEqual([6, 10]);
+    });
+
+    it('should identify truncation when reading the end of a file', async () => {
+      const lines = Array.from({ length: 20 }, (_, i) => `Line ${i + 1}`);
+      actualNodeFs.writeFileSync(testTextFilePath, lines.join('\n'));
+
+      // Read from line 11 to 20. The start is not 0, so it's truncated.
+      const result = await processSingleFileContent(
+        testTextFilePath,
+        tempRootDir,
+        new StandardFileSystemService(),
+        10,
+        10,
+      );
+      const expectedContent = lines.slice(10, 20).join('\n');
+
+      expect(result.llmContent).toContain(expectedContent);
+      expect(result.returnDisplay).toBe('Read lines 11-20 of 20 from test.txt');
+      expect(result.isTruncated).toBe(true); // This is the key check for the bug
+      expect(result.originalLineCount).toBe(20);
+      expect(result.linesShown).toEqual([11, 20]);
+    });
+
+    it('should handle limit exceeding file length', async () => {
+      const lines = ['Line 1', 'Line 2'];
+      actualNodeFs.writeFileSync(testTextFilePath, lines.join('\n'));
+
+      const result = await processSingleFileContent(
+        testTextFilePath,
+        tempRootDir,
+        new StandardFileSystemService(),
+        0,
+        10,
+      );
+      const expectedContent = lines.join('\n');
+
+      expect(result.llmContent).toBe(expectedContent);
+      expect(result.returnDisplay).toBe('');
+      expect(result.isTruncated).toBe(false);
+      expect(result.originalLineCount).toBe(2);
+      expect(result.linesShown).toEqual([1, 2]);
+    });
+
+    it('should truncate long lines in text files', async () => {
+      const longLine = 'a'.repeat(2500);
+      actualNodeFs.writeFileSync(
+        testTextFilePath,
+        `Short line\n${longLine}\nAnother short line`,
+      );
+
+      const result = await processSingleFileContent(
+        testTextFilePath,
+        tempRootDir,
+        new StandardFileSystemService(),
+      );
+
+      expect(result.llmContent).toContain('Short line');
+      expect(result.llmContent).toContain(
+        longLine.substring(0, 2000) + '... [truncated]',
+      );
+      expect(result.llmContent).toContain('Another short line');
+      expect(result.returnDisplay).toBe(
+        'Read all 3 lines from test.txt (some lines were shortened)',
+      );
+      expect(result.isTruncated).toBe(true);
+    });
+
+    it('should truncate when line count exceeds the limit', async () => {
+      const lines = Array.from({ length: 11 }, (_, i) => `Line ${i + 1}`);
+      actualNodeFs.writeFileSync(testTextFilePath, lines.join('\n'));
+
+      // Read 5 lines, but there are 11 total
+      const result = await processSingleFileContent(
+        testTextFilePath,
+        tempRootDir,
+        new StandardFileSystemService(),
+        0,
+        5,
+      );
+
+      expect(result.isTruncated).toBe(true);
+      expect(result.returnDisplay).toBe('Read lines 1-5 of 11 from test.txt');
+    });
+
+    it('should truncate when a line length exceeds the character limit', async () => {
+      const longLine = 'b'.repeat(2500);
+      const lines = Array.from({ length: 10 }, (_, i) => `Line ${i + 1}`);
+      lines.push(longLine); // Total 11 lines
+      actualNodeFs.writeFileSync(testTextFilePath, lines.join('\n'));
+
+      // Read all 11 lines, including the long one
+      const result = await processSingleFileContent(
+        testTextFilePath,
+        tempRootDir,
+        new StandardFileSystemService(),
+        0,
+        11,
+      );
+
+      expect(result.isTruncated).toBe(true);
+      expect(result.returnDisplay).toBe(
+        'Read all 11 lines from test.txt (some lines were shortened)',
+      );
+    });
+
+    it('should truncate both line count and line length when both exceed limits', async () => {
+      const linesWithLongInMiddle = Array.from(
+        { length: 20 },
+        (_, i) => `Line ${i + 1}`,
+      );
+      linesWithLongInMiddle[4] = 'c'.repeat(2500);
+      actualNodeFs.writeFileSync(
+        testTextFilePath,
+        linesWithLongInMiddle.join('\n'),
+      );
+
+      // Read 10 lines out of 20, including the long line
+      const result = await processSingleFileContent(
+        testTextFilePath,
+        tempRootDir,
+        new StandardFileSystemService(),
+        0,
+        10,
+      );
+      expect(result.isTruncated).toBe(true);
+      expect(result.returnDisplay).toBe(
+        'Read lines 1-10 of 20 from test.txt (some lines were shortened)',
+      );
+    });
+
+    it('should return an error if the file size exceeds 20MB', async () => {
+      // Create a file just over 20MB
+      const twentyOneMB = 21 * 1024 * 1024;
+      const buffer = Buffer.alloc(twentyOneMB, 0x61); // Fill with 'a'
+      actualNodeFs.writeFileSync(testTextFilePath, buffer);
+
+      const result = await processSingleFileContent(
+        testTextFilePath,
+        tempRootDir,
+        new StandardFileSystemService(),
+      );
+
+      expect(result.error).toContain('File size exceeds the 20MB limit');
+      expect(result.returnDisplay).toContain(
+        'File size exceeds the 20MB limit',
+      );
+      expect(result.llmContent).toContain('File size exceeds the 20MB limit');
+    });
+  });
+});

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

@@ -0,0 +1,378 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import fs from 'node:fs';
+import path from 'node:path';
+import { PartUnion } from '@google/genai';
+import mime from 'mime-types';
+import { FileSystemService } from '../services/fileSystemService.js';
+
+// Constants for text file processing
+const DEFAULT_MAX_LINES_TEXT_FILE = 2000;
+const MAX_LINE_LENGTH_TEXT_FILE = 2000;
+
+// Default values for encoding and separator format
+export const DEFAULT_ENCODING: BufferEncoding = 'utf-8';
+
+/**
+ * Looks up the specific MIME type for a file path.
+ * @param filePath Path to the file.
+ * @returns The specific MIME type string (e.g., 'text/python', 'application/javascript') or undefined if not found or ambiguous.
+ */
+export function getSpecificMimeType(filePath: string): string | undefined {
+  const lookedUpMime = mime.lookup(filePath);
+  return typeof lookedUpMime === 'string' ? lookedUpMime : undefined;
+}
+
+/**
+ * Checks if a path is within a given root directory.
+ * @param pathToCheck The absolute path to check.
+ * @param rootDirectory The absolute root directory.
+ * @returns True if the path is within the root directory, false otherwise.
+ */
+export function isWithinRoot(
+  pathToCheck: string,
+  rootDirectory: string,
+): boolean {
+  const normalizedPathToCheck = path.resolve(pathToCheck);
+  const normalizedRootDirectory = path.resolve(rootDirectory);
+
+  // Ensure the rootDirectory path ends with a separator for correct startsWith comparison,
+  // unless it's the root path itself (e.g., '/' or 'C:\').
+  const rootWithSeparator =
+    normalizedRootDirectory === path.sep ||
+    normalizedRootDirectory.endsWith(path.sep)
+      ? normalizedRootDirectory
+      : normalizedRootDirectory + path.sep;
+
+  return (
+    normalizedPathToCheck === normalizedRootDirectory ||
+    normalizedPathToCheck.startsWith(rootWithSeparator)
+  );
+}
+
+/**
+ * Determines if a file is likely binary based on content sampling.
+ * @param filePath Path to the file.
+ * @returns Promise that resolves to true if the file appears to be binary.
+ */
+export async function isBinaryFile(filePath: string): Promise<boolean> {
+  let fileHandle: fs.promises.FileHandle | undefined;
+  try {
+    fileHandle = await fs.promises.open(filePath, 'r');
+
+    // Read up to 4KB or file size, whichever is smaller
+    const stats = await fileHandle.stat();
+    const fileSize = stats.size;
+    if (fileSize === 0) {
+      // Empty file is not considered binary for content checking
+      return false;
+    }
+    const bufferSize = Math.min(4096, fileSize);
+    const buffer = Buffer.alloc(bufferSize);
+    const result = await fileHandle.read(buffer, 0, buffer.length, 0);
+    const bytesRead = result.bytesRead;
+
+    if (bytesRead === 0) return false;
+
+    let nonPrintableCount = 0;
+    for (let i = 0; i < bytesRead; i++) {
+      if (buffer[i] === 0) return true; // Null byte is a strong indicator
+      if (buffer[i] < 9 || (buffer[i] > 13 && buffer[i] < 32)) {
+        nonPrintableCount++;
+      }
+    }
+    // If >30% non-printable characters, consider it binary
+    return nonPrintableCount / bytesRead > 0.3;
+  } catch (error) {
+    // Log error for debugging while maintaining existing behavior
+    console.warn(
+      `Failed to check if file is binary: ${filePath}`,
+      error instanceof Error ? error.message : String(error),
+    );
+    // If any error occurs (e.g. file not found, permissions),
+    // treat as not binary here; let higher-level functions handle existence/access errors.
+    return false;
+  } finally {
+    // Safely close the file handle if it was successfully opened
+    if (fileHandle) {
+      try {
+        await fileHandle.close();
+      } catch (closeError) {
+        // Log close errors for debugging while continuing with cleanup
+        console.warn(
+          `Failed to close file handle for: ${filePath}`,
+          closeError instanceof Error ? closeError.message : String(closeError),
+        );
+        // The important thing is that we attempted to clean up
+      }
+    }
+  }
+}
+
+/**
+ * Detects the type of file based on extension and content.
+ * @param filePath Path to the file.
+ * @returns Promise that resolves to 'text', 'image', 'pdf', 'audio', 'video', 'binary' or 'svg'.
+ */
+export async function detectFileType(
+  filePath: string,
+): Promise<'text' | 'image' | 'pdf' | 'audio' | 'video' | 'binary' | 'svg'> {
+  const ext = path.extname(filePath).toLowerCase();
+
+  // The mimetype for various TypeScript extensions (ts, mts, cts, tsx) can be
+  // MPEG transport stream (a video format), but we want to assume these are
+  // TypeScript files instead.
+  if (['.ts', '.mts', '.cts'].includes(ext)) {
+    return 'text';
+  }
+
+  if (ext === '.svg') {
+    return 'svg';
+  }
+
+  const lookedUpMimeType = mime.lookup(filePath); // Returns false if not found, or the mime type string
+  if (lookedUpMimeType) {
+    if (lookedUpMimeType.startsWith('image/')) {
+      return 'image';
+    }
+    if (lookedUpMimeType.startsWith('audio/')) {
+      return 'audio';
+    }
+    if (lookedUpMimeType.startsWith('video/')) {
+      return 'video';
+    }
+    if (lookedUpMimeType === 'application/pdf') {
+      return 'pdf';
+    }
+  }
+
+  // Stricter binary check for common non-text extensions before content check
+  // These are often not well-covered by mime-types or might be misidentified.
+  if (
+    [
+      '.zip',
+      '.tar',
+      '.gz',
+      '.exe',
+      '.dll',
+      '.so',
+      '.class',
+      '.jar',
+      '.war',
+      '.7z',
+      '.doc',
+      '.docx',
+      '.xls',
+      '.xlsx',
+      '.ppt',
+      '.pptx',
+      '.odt',
+      '.ods',
+      '.odp',
+      '.bin',
+      '.dat',
+      '.obj',
+      '.o',
+      '.a',
+      '.lib',
+      '.wasm',
+      '.pyc',
+      '.pyo',
+    ].includes(ext)
+  ) {
+    return 'binary';
+  }
+
+  // Fall back to content-based check if mime type wasn't conclusive for image/pdf
+  // and it's not a known binary extension.
+  if (await isBinaryFile(filePath)) {
+    return 'binary';
+  }
+
+  return 'text';
+}
+
+export enum FileErrorType {
+  FILE_NOT_FOUND = 'FILE_NOT_FOUND',
+  IS_DIRECTORY = 'IS_DIRECTORY',
+  FILE_TOO_LARGE = 'FILE_TOO_LARGE',
+  READ_ERROR = 'READ_ERROR',
+}
+
+export interface ProcessedFileReadResult {
+  llmContent: PartUnion; // string for text, Part for image/pdf/unreadable binary
+  returnDisplay: string;
+  error?: string; // Optional error message for the LLM if file processing failed
+  errorType?: FileErrorType; // Structured error type using enum
+  isTruncated?: boolean; // For text files, indicates if content was truncated
+  originalLineCount?: number; // For text files
+  linesShown?: [number, number]; // For text files [startLine, endLine] (1-based for display)
+}
+
+/**
+ * Reads and processes a single file, handling text, images, and PDFs.
+ * @param filePath Absolute path to the file.
+ * @param rootDirectory Absolute path to the project root for relative path display.
+ * @param offset Optional offset for text files (0-based line number).
+ * @param limit Optional limit for text files (number of lines to read).
+ * @returns ProcessedFileReadResult object.
+ */
+export async function processSingleFileContent(
+  filePath: string,
+  rootDirectory: string,
+  fileSystemService: FileSystemService,
+  offset?: number,
+  limit?: number,
+): Promise<ProcessedFileReadResult> {
+  try {
+    if (!fs.existsSync(filePath)) {
+      // Sync check is acceptable before async read
+      return {
+        llmContent: '',
+        returnDisplay: 'File not found.',
+        error: `File not found: ${filePath}`,
+        errorType: FileErrorType.FILE_NOT_FOUND,
+      };
+    }
+    const stats = await fs.promises.stat(filePath);
+    if (stats.isDirectory()) {
+      return {
+        llmContent: '',
+        returnDisplay: 'Path is a directory.',
+        error: `Path is a directory, not a file: ${filePath}`,
+        errorType: FileErrorType.IS_DIRECTORY,
+      };
+    }
+
+    const fileSizeInBytes = stats.size;
+    // 20MB limit
+    const maxFileSize = 20 * 1024 * 1024;
+
+    if (fileSizeInBytes > maxFileSize) {
+      throw new Error(
+        `File size exceeds the 20MB limit: ${filePath} (${(
+          fileSizeInBytes /
+          (1024 * 1024)
+        ).toFixed(2)}MB)`,
+      );
+    }
+
+    const fileType = await detectFileType(filePath);
+    const relativePathForDisplay = path
+      .relative(rootDirectory, filePath)
+      .replace(/\\/g, '/');
+
+    switch (fileType) {
+      case 'binary': {
+        return {
+          llmContent: `Cannot display content of binary file: ${relativePathForDisplay}`,
+          returnDisplay: `Skipped binary file: ${relativePathForDisplay}`,
+        };
+      }
+      case 'svg': {
+        const SVG_MAX_SIZE_BYTES = 1 * 1024 * 1024;
+        if (stats.size > SVG_MAX_SIZE_BYTES) {
+          return {
+            llmContent: `Cannot display content of SVG file larger than 1MB: ${relativePathForDisplay}`,
+            returnDisplay: `Skipped large SVG file (>1MB): ${relativePathForDisplay}`,
+          };
+        }
+        const content = await fileSystemService.readTextFile(filePath);
+        return {
+          llmContent: content,
+          returnDisplay: `Read SVG as text: ${relativePathForDisplay}`,
+        };
+      }
+      case 'text': {
+        const content = await fileSystemService.readTextFile(filePath);
+        const lines = content.split('\n');
+        const originalLineCount = lines.length;
+
+        const startLine = offset || 0;
+        const effectiveLimit =
+          limit === undefined ? DEFAULT_MAX_LINES_TEXT_FILE : limit;
+        // Ensure endLine does not exceed originalLineCount
+        const endLine = Math.min(startLine + effectiveLimit, originalLineCount);
+        // Ensure selectedLines doesn't try to slice beyond array bounds if startLine is too high
+        const actualStartLine = Math.min(startLine, originalLineCount);
+        const selectedLines = lines.slice(actualStartLine, endLine);
+
+        let linesWereTruncatedInLength = false;
+        const formattedLines = selectedLines.map((line) => {
+          if (line.length > MAX_LINE_LENGTH_TEXT_FILE) {
+            linesWereTruncatedInLength = true;
+            return (
+              line.substring(0, MAX_LINE_LENGTH_TEXT_FILE) + '... [truncated]'
+            );
+          }
+          return line;
+        });
+
+        const contentRangeTruncated =
+          startLine > 0 || endLine < originalLineCount;
+        const isTruncated = contentRangeTruncated || linesWereTruncatedInLength;
+        const llmContent = formattedLines.join('\n');
+
+        // By default, return nothing to streamline the common case of a successful read_file.
+        let returnDisplay = '';
+        if (contentRangeTruncated) {
+          returnDisplay = `Read lines ${
+            actualStartLine + 1
+          }-${endLine} of ${originalLineCount} from ${relativePathForDisplay}`;
+          if (linesWereTruncatedInLength) {
+            returnDisplay += ' (some lines were shortened)';
+          }
+        } else if (linesWereTruncatedInLength) {
+          returnDisplay = `Read all ${originalLineCount} lines from ${relativePathForDisplay} (some lines were shortened)`;
+        }
+
+        return {
+          llmContent,
+          returnDisplay,
+          isTruncated,
+          originalLineCount,
+          linesShown: [actualStartLine + 1, endLine],
+        };
+      }
+      case 'image':
+      case 'pdf':
+      case 'audio':
+      case 'video': {
+        const contentBuffer = await fs.promises.readFile(filePath);
+        const base64Data = contentBuffer.toString('base64');
+        return {
+          llmContent: {
+            inlineData: {
+              data: base64Data,
+              mimeType: mime.lookup(filePath) || 'application/octet-stream',
+            },
+          },
+          returnDisplay: `Read ${fileType} file: ${relativePathForDisplay}`,
+        };
+      }
+      default: {
+        // Should not happen with current detectFileType logic
+        const exhaustiveCheck: never = fileType;
+        return {
+          llmContent: `Unhandled file type: ${exhaustiveCheck}`,
+          returnDisplay: `Skipped unhandled file type: ${relativePathForDisplay}`,
+          error: `Unhandled file type for ${filePath}`,
+        };
+      }
+    }
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    const displayPath = path
+      .relative(rootDirectory, filePath)
+      .replace(/\\/g, '/');
+    return {
+      llmContent: `Error reading file ${displayPath}: ${errorMessage}`,
+      returnDisplay: `Error reading file ${displayPath}: ${errorMessage}`,
+      error: `Error reading file ${filePath}: ${errorMessage}`,
+    };
+  }
+}

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

@@ -0,0 +1,153 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { Config } from '../config/config.js';
+import fs from 'node:fs';
+import {
+  setSimulate429,
+  disableSimulationAfterFallback,
+  shouldSimulate429,
+  createSimulated429Error,
+  resetRequestCounter,
+} from './testUtils.js';
+import { DEFAULT_GEMINI_FLASH_MODEL } from '../config/models.js';
+import { retryWithBackoff } from './retry.js';
+import { AuthType } from '../core/contentGenerator.js';
+
+vi.mock('node:fs');
+
+vi.mock('node:fs');
+
+describe('Flash Fallback Integration', () => {
+  let config: Config;
+
+  beforeEach(() => {
+    vi.mocked(fs.existsSync).mockReturnValue(true);
+    vi.mocked(fs.statSync).mockReturnValue({
+      isDirectory: () => true,
+    } as fs.Stats);
+    config = new Config({
+      sessionId: 'test-session',
+      targetDir: '/test',
+      debugMode: false,
+      cwd: '/test',
+      model: 'gemini-2.5-pro',
+    });
+
+    // Reset simulation state for each test
+    setSimulate429(false);
+    resetRequestCounter();
+  });
+
+  it('should automatically accept fallback', async () => {
+    // Set up a minimal flash fallback handler for testing
+    const flashFallbackHandler = async (): Promise<boolean> => true;
+
+    config.setFlashFallbackHandler(flashFallbackHandler);
+
+    // Call the handler directly to test
+    const result = await config.flashFallbackHandler!(
+      'gemini-2.5-pro',
+      DEFAULT_GEMINI_FLASH_MODEL,
+    );
+
+    // Verify it automatically accepts
+    expect(result).toBe(true);
+  });
+
+  it('should trigger fallback after 2 consecutive 429 errors for OAuth users', async () => {
+    let fallbackCalled = false;
+    let fallbackModel = '';
+
+    // Mock function that simulates exactly 2 429 errors, then succeeds after fallback
+    const mockApiCall = vi
+      .fn()
+      .mockRejectedValueOnce(createSimulated429Error())
+      .mockRejectedValueOnce(createSimulated429Error())
+      .mockResolvedValueOnce('success after fallback');
+
+    // Mock fallback handler
+    const mockFallbackHandler = vi.fn(async (_authType?: string) => {
+      fallbackCalled = true;
+      fallbackModel = DEFAULT_GEMINI_FLASH_MODEL;
+      return fallbackModel;
+    });
+
+    // Test with OAuth personal auth type, with maxAttempts = 2 to ensure fallback triggers
+    const result = await retryWithBackoff(mockApiCall, {
+      maxAttempts: 2,
+      initialDelayMs: 1,
+      maxDelayMs: 10,
+      shouldRetry: (error: Error) => {
+        const status = (error as Error & { status?: number }).status;
+        return status === 429;
+      },
+      onPersistent429: mockFallbackHandler,
+      authType: AuthType.LOGIN_WITH_GOOGLE,
+    });
+
+    // Verify fallback was triggered
+    expect(fallbackCalled).toBe(true);
+    expect(fallbackModel).toBe(DEFAULT_GEMINI_FLASH_MODEL);
+    expect(mockFallbackHandler).toHaveBeenCalledWith(
+      AuthType.LOGIN_WITH_GOOGLE,
+      expect.any(Error),
+    );
+    expect(result).toBe('success after fallback');
+    // Should have: 2 failures, then fallback triggered, then 1 success after retry reset
+    expect(mockApiCall).toHaveBeenCalledTimes(3);
+  });
+
+  it('should not trigger fallback for API key users', async () => {
+    let fallbackCalled = false;
+
+    // Mock function that simulates 429 errors
+    const mockApiCall = vi.fn().mockRejectedValue(createSimulated429Error());
+
+    // Mock fallback handler
+    const mockFallbackHandler = vi.fn(async () => {
+      fallbackCalled = true;
+      return DEFAULT_GEMINI_FLASH_MODEL;
+    });
+
+    // Test with API key auth type - should not trigger fallback
+    try {
+      await retryWithBackoff(mockApiCall, {
+        maxAttempts: 5,
+        initialDelayMs: 10,
+        maxDelayMs: 100,
+        shouldRetry: (error: Error) => {
+          const status = (error as Error & { status?: number }).status;
+          return status === 429;
+        },
+        onPersistent429: mockFallbackHandler,
+        authType: AuthType.USE_GEMINI, // API key auth type
+      });
+    } catch (error) {
+      // Expected to throw after max attempts
+      expect((error as Error).message).toContain('Rate limit exceeded');
+    }
+
+    // Verify fallback was NOT triggered for API key users
+    expect(fallbackCalled).toBe(false);
+    expect(mockFallbackHandler).not.toHaveBeenCalled();
+  });
+
+  it('should properly disable simulation state after fallback', () => {
+    // Enable simulation
+    setSimulate429(true);
+
+    // Verify simulation is enabled
+    expect(shouldSimulate429()).toBe(true);
+
+    // Disable simulation after fallback
+    disableSimulationAfterFallback();
+
+    // Verify simulation is now disabled
+    expect(shouldSimulate429()).toBe(false);
+  });
+});

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

@@ -0,0 +1,16 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+export const formatMemoryUsage = (bytes: number): string => {
+  const gb = bytes / (1024 * 1024 * 1024);
+  if (bytes < 1024 * 1024) {
+    return `${(bytes / 1024).toFixed(1)} KB`;
+  }
+  if (bytes < 1024 * 1024 * 1024) {
+    return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+  }
+  return `${gb.toFixed(2)} GB`;
+};

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

@@ -0,0 +1,323 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { describe, it, expect } from 'vitest';
+import {
+  getResponseText,
+  getResponseTextFromParts,
+  getFunctionCalls,
+  getFunctionCallsFromParts,
+  getFunctionCallsAsJson,
+  getFunctionCallsFromPartsAsJson,
+  getStructuredResponse,
+  getStructuredResponseFromParts,
+} from './generateContentResponseUtilities.js';
+import {
+  GenerateContentResponse,
+  Part,
+  FinishReason,
+  SafetyRating,
+} from '@google/genai';
+
+const mockTextPart = (text: string): Part => ({ text });
+const mockFunctionCallPart = (
+  name: string,
+  args?: Record<string, unknown>,
+): Part => ({
+  functionCall: { name, args: args ?? {} },
+});
+
+const mockResponse = (
+  parts: Part[],
+  finishReason: FinishReason = FinishReason.STOP,
+  safetyRatings: SafetyRating[] = [],
+): GenerateContentResponse => ({
+  candidates: [
+    {
+      content: {
+        parts,
+        role: 'model',
+      },
+      index: 0,
+      finishReason,
+      safetyRatings,
+    },
+  ],
+  promptFeedback: {
+    safetyRatings: [],
+  },
+  text: undefined,
+  data: undefined,
+  functionCalls: undefined,
+  executableCode: undefined,
+  codeExecutionResult: undefined,
+});
+
+const minimalMockResponse = (
+  candidates: GenerateContentResponse['candidates'],
+): GenerateContentResponse => ({
+  candidates,
+  promptFeedback: { safetyRatings: [] },
+  text: undefined,
+  data: undefined,
+  functionCalls: undefined,
+  executableCode: undefined,
+  codeExecutionResult: undefined,
+});
+
+describe('generateContentResponseUtilities', () => {
+  describe('getResponseText', () => {
+    it('should return undefined for no candidates', () => {
+      expect(getResponseText(minimalMockResponse(undefined))).toBeUndefined();
+    });
+    it('should return undefined for empty candidates array', () => {
+      expect(getResponseText(minimalMockResponse([]))).toBeUndefined();
+    });
+    it('should return undefined for no parts', () => {
+      const response = mockResponse([]);
+      expect(getResponseText(response)).toBeUndefined();
+    });
+    it('should extract text from a single text part', () => {
+      const response = mockResponse([mockTextPart('Hello')]);
+      expect(getResponseText(response)).toBe('Hello');
+    });
+    it('should concatenate text from multiple text parts', () => {
+      const response = mockResponse([
+        mockTextPart('Hello '),
+        mockTextPart('World'),
+      ]);
+      expect(getResponseText(response)).toBe('Hello World');
+    });
+    it('should ignore function call parts', () => {
+      const response = mockResponse([
+        mockTextPart('Hello '),
+        mockFunctionCallPart('testFunc'),
+        mockTextPart('World'),
+      ]);
+      expect(getResponseText(response)).toBe('Hello World');
+    });
+    it('should return undefined if only function call parts exist', () => {
+      const response = mockResponse([
+        mockFunctionCallPart('testFunc'),
+        mockFunctionCallPart('anotherFunc'),
+      ]);
+      expect(getResponseText(response)).toBeUndefined();
+    });
+  });
+
+  describe('getResponseTextFromParts', () => {
+    it('should return undefined for no parts', () => {
+      expect(getResponseTextFromParts([])).toBeUndefined();
+    });
+    it('should extract text from a single text part', () => {
+      expect(getResponseTextFromParts([mockTextPart('Hello')])).toBe('Hello');
+    });
+    it('should concatenate text from multiple text parts', () => {
+      expect(
+        getResponseTextFromParts([
+          mockTextPart('Hello '),
+          mockTextPart('World'),
+        ]),
+      ).toBe('Hello World');
+    });
+    it('should ignore function call parts', () => {
+      expect(
+        getResponseTextFromParts([
+          mockTextPart('Hello '),
+          mockFunctionCallPart('testFunc'),
+          mockTextPart('World'),
+        ]),
+      ).toBe('Hello World');
+    });
+    it('should return undefined if only function call parts exist', () => {
+      expect(
+        getResponseTextFromParts([
+          mockFunctionCallPart('testFunc'),
+          mockFunctionCallPart('anotherFunc'),
+        ]),
+      ).toBeUndefined();
+    });
+  });
+
+  describe('getFunctionCalls', () => {
+    it('should return undefined for no candidates', () => {
+      expect(getFunctionCalls(minimalMockResponse(undefined))).toBeUndefined();
+    });
+    it('should return undefined for empty candidates array', () => {
+      expect(getFunctionCalls(minimalMockResponse([]))).toBeUndefined();
+    });
+    it('should return undefined for no parts', () => {
+      const response = mockResponse([]);
+      expect(getFunctionCalls(response)).toBeUndefined();
+    });
+    it('should extract a single function call', () => {
+      const func = { name: 'testFunc', args: { a: 1 } };
+      const response = mockResponse([
+        mockFunctionCallPart(func.name, func.args),
+      ]);
+      expect(getFunctionCalls(response)).toEqual([func]);
+    });
+    it('should extract multiple function calls', () => {
+      const func1 = { name: 'testFunc1', args: { a: 1 } };
+      const func2 = { name: 'testFunc2', args: { b: 2 } };
+      const response = mockResponse([
+        mockFunctionCallPart(func1.name, func1.args),
+        mockFunctionCallPart(func2.name, func2.args),
+      ]);
+      expect(getFunctionCalls(response)).toEqual([func1, func2]);
+    });
+    it('should ignore text parts', () => {
+      const func = { name: 'testFunc', args: { a: 1 } };
+      const response = mockResponse([
+        mockTextPart('Some text'),
+        mockFunctionCallPart(func.name, func.args),
+        mockTextPart('More text'),
+      ]);
+      expect(getFunctionCalls(response)).toEqual([func]);
+    });
+    it('should return undefined if only text parts exist', () => {
+      const response = mockResponse([
+        mockTextPart('Some text'),
+        mockTextPart('More text'),
+      ]);
+      expect(getFunctionCalls(response)).toBeUndefined();
+    });
+  });
+
+  describe('getFunctionCallsFromParts', () => {
+    it('should return undefined for no parts', () => {
+      expect(getFunctionCallsFromParts([])).toBeUndefined();
+    });
+    it('should extract a single function call', () => {
+      const func = { name: 'testFunc', args: { a: 1 } };
+      expect(
+        getFunctionCallsFromParts([mockFunctionCallPart(func.name, func.args)]),
+      ).toEqual([func]);
+    });
+    it('should extract multiple function calls', () => {
+      const func1 = { name: 'testFunc1', args: { a: 1 } };
+      const func2 = { name: 'testFunc2', args: { b: 2 } };
+      expect(
+        getFunctionCallsFromParts([
+          mockFunctionCallPart(func1.name, func1.args),
+          mockFunctionCallPart(func2.name, func2.args),
+        ]),
+      ).toEqual([func1, func2]);
+    });
+    it('should ignore text parts', () => {
+      const func = { name: 'testFunc', args: { a: 1 } };
+      expect(
+        getFunctionCallsFromParts([
+          mockTextPart('Some text'),
+          mockFunctionCallPart(func.name, func.args),
+          mockTextPart('More text'),
+        ]),
+      ).toEqual([func]);
+    });
+    it('should return undefined if only text parts exist', () => {
+      expect(
+        getFunctionCallsFromParts([
+          mockTextPart('Some text'),
+          mockTextPart('More text'),
+        ]),
+      ).toBeUndefined();
+    });
+  });
+
+  describe('getFunctionCallsAsJson', () => {
+    it('should return JSON string of function calls', () => {
+      const func1 = { name: 'testFunc1', args: { a: 1 } };
+      const func2 = { name: 'testFunc2', args: { b: 2 } };
+      const response = mockResponse([
+        mockFunctionCallPart(func1.name, func1.args),
+        mockTextPart('text in between'),
+        mockFunctionCallPart(func2.name, func2.args),
+      ]);
+      const expectedJson = JSON.stringify([func1, func2], null, 2);
+      expect(getFunctionCallsAsJson(response)).toBe(expectedJson);
+    });
+    it('should return undefined if no function calls', () => {
+      const response = mockResponse([mockTextPart('Hello')]);
+      expect(getFunctionCallsAsJson(response)).toBeUndefined();
+    });
+  });
+
+  describe('getFunctionCallsFromPartsAsJson', () => {
+    it('should return JSON string of function calls from parts', () => {
+      const func1 = { name: 'testFunc1', args: { a: 1 } };
+      const func2 = { name: 'testFunc2', args: { b: 2 } };
+      const parts = [
+        mockFunctionCallPart(func1.name, func1.args),
+        mockTextPart('text in between'),
+        mockFunctionCallPart(func2.name, func2.args),
+      ];
+      const expectedJson = JSON.stringify([func1, func2], null, 2);
+      expect(getFunctionCallsFromPartsAsJson(parts)).toBe(expectedJson);
+    });
+    it('should return undefined if no function calls in parts', () => {
+      const parts = [mockTextPart('Hello')];
+      expect(getFunctionCallsFromPartsAsJson(parts)).toBeUndefined();
+    });
+  });
+
+  describe('getStructuredResponse', () => {
+    it('should return only text if only text exists', () => {
+      const response = mockResponse([mockTextPart('Hello World')]);
+      expect(getStructuredResponse(response)).toBe('Hello World');
+    });
+    it('should return only function call JSON if only function calls exist', () => {
+      const func = { name: 'testFunc', args: { data: 'payload' } };
+      const response = mockResponse([
+        mockFunctionCallPart(func.name, func.args),
+      ]);
+      const expectedJson = JSON.stringify([func], null, 2);
+      expect(getStructuredResponse(response)).toBe(expectedJson);
+    });
+    it('should return text and function call JSON if both exist', () => {
+      const text = 'Consider this data:';
+      const func = { name: 'processData', args: { item: 42 } };
+      const response = mockResponse([
+        mockTextPart(text),
+        mockFunctionCallPart(func.name, func.args),
+      ]);
+      const expectedJson = JSON.stringify([func], null, 2);
+      expect(getStructuredResponse(response)).toBe(`${text}\n${expectedJson}`);
+    });
+    it('should return undefined if neither text nor function calls exist', () => {
+      const response = mockResponse([]);
+      expect(getStructuredResponse(response)).toBeUndefined();
+    });
+  });
+
+  describe('getStructuredResponseFromParts', () => {
+    it('should return only text if only text exists in parts', () => {
+      const parts = [mockTextPart('Hello World')];
+      expect(getStructuredResponseFromParts(parts)).toBe('Hello World');
+    });
+    it('should return only function call JSON if only function calls exist in parts', () => {
+      const func = { name: 'testFunc', args: { data: 'payload' } };
+      const parts = [mockFunctionCallPart(func.name, func.args)];
+      const expectedJson = JSON.stringify([func], null, 2);
+      expect(getStructuredResponseFromParts(parts)).toBe(expectedJson);
+    });
+    it('should return text and function call JSON if both exist in parts', () => {
+      const text = 'Consider this data:';
+      const func = { name: 'processData', args: { item: 42 } };
+      const parts = [
+        mockTextPart(text),
+        mockFunctionCallPart(func.name, func.args),
+      ];
+      const expectedJson = JSON.stringify([func], null, 2);
+      expect(getStructuredResponseFromParts(parts)).toBe(
+        `${text}\n${expectedJson}`,
+      );
+    });
+    it('should return undefined if neither text nor function calls exist in parts', () => {
+      const parts: Part[] = [];
+      expect(getStructuredResponseFromParts(parts)).toBeUndefined();
+    });
+  });
+});

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

@@ -0,0 +1,119 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { GenerateContentResponse, Part, FunctionCall } from '@google/genai';
+
+export function getResponseText(
+  response: GenerateContentResponse,
+): string | undefined {
+  const parts = response.candidates?.[0]?.content?.parts;
+  if (!parts) {
+    return undefined;
+  }
+  const textSegments = parts
+    .map((part) => part.text)
+    .filter((text): text is string => typeof text === 'string');
+
+  if (textSegments.length === 0) {
+    return undefined;
+  }
+  return textSegments.join('');
+}
+
+export function getResponseTextFromParts(parts: Part[]): string | undefined {
+  if (!parts) {
+    return undefined;
+  }
+  const textSegments = parts
+    .map((part) => part.text)
+    .filter((text): text is string => typeof text === 'string');
+
+  if (textSegments.length === 0) {
+    return undefined;
+  }
+  return textSegments.join('');
+}
+
+export function getFunctionCalls(
+  response: GenerateContentResponse,
+): FunctionCall[] | undefined {
+  const parts = response.candidates?.[0]?.content?.parts;
+  if (!parts) {
+    return undefined;
+  }
+  const functionCallParts = parts
+    .filter((part) => !!part.functionCall)
+    .map((part) => part.functionCall as FunctionCall);
+  return functionCallParts.length > 0 ? functionCallParts : undefined;
+}
+
+export function getFunctionCallsFromParts(
+  parts: Part[],
+): FunctionCall[] | undefined {
+  if (!parts) {
+    return undefined;
+  }
+  const functionCallParts = parts
+    .filter((part) => !!part.functionCall)
+    .map((part) => part.functionCall as FunctionCall);
+  return functionCallParts.length > 0 ? functionCallParts : undefined;
+}
+
+export function getFunctionCallsAsJson(
+  response: GenerateContentResponse,
+): string | undefined {
+  const functionCalls = getFunctionCalls(response);
+  if (!functionCalls) {
+    return undefined;
+  }
+  return JSON.stringify(functionCalls, null, 2);
+}
+
+export function getFunctionCallsFromPartsAsJson(
+  parts: Part[],
+): string | undefined {
+  const functionCalls = getFunctionCallsFromParts(parts);
+  if (!functionCalls) {
+    return undefined;
+  }
+  return JSON.stringify(functionCalls, null, 2);
+}
+
+export function getStructuredResponse(
+  response: GenerateContentResponse,
+): string | undefined {
+  const textContent = getResponseText(response);
+  const functionCallsJson = getFunctionCallsAsJson(response);
+
+  if (textContent && functionCallsJson) {
+    return `${textContent}\n${functionCallsJson}`;
+  }
+  if (textContent) {
+    return textContent;
+  }
+  if (functionCallsJson) {
+    return functionCallsJson;
+  }
+  return undefined;
+}
+
+export function getStructuredResponseFromParts(
+  parts: Part[],
+): string | undefined {
+  const textContent = getResponseTextFromParts(parts);
+  const functionCallsJson = getFunctionCallsFromPartsAsJson(parts);
+
+  if (textContent && functionCallsJson) {
+    return `${textContent}\n${functionCallsJson}`;
+  }
+  if (textContent) {
+    return textContent;
+  }
+  if (functionCallsJson) {
+    return functionCallsJson;
+  }
+  return undefined;
+}

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

@@ -0,0 +1,340 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import fsPromises from 'fs/promises';
+import * as nodePath from 'path';
+import * as os from 'os';
+import { getFolderStructure } from './getFolderStructure.js';
+import { FileDiscoveryService } from '../services/fileDiscoveryService.js';
+import * as path from 'path';
+
+describe('getFolderStructure', () => {
+  let testRootDir: string;
+
+  async function createEmptyDir(...pathSegments: string[]) {
+    const fullPath = path.join(testRootDir, ...pathSegments);
+    await fsPromises.mkdir(fullPath, { recursive: true });
+  }
+
+  async function createTestFile(...pathSegments: string[]) {
+    const fullPath = path.join(testRootDir, ...pathSegments);
+    await fsPromises.mkdir(path.dirname(fullPath), { recursive: true });
+    await fsPromises.writeFile(fullPath, '');
+    return fullPath;
+  }
+
+  beforeEach(async () => {
+    testRootDir = await fsPromises.mkdtemp(
+      path.join(os.tmpdir(), 'folder-structure-test-'),
+    );
+  });
+
+  afterEach(async () => {
+    await fsPromises.rm(testRootDir, { recursive: true, force: true });
+  });
+
+  it('should return basic folder structure', async () => {
+    await createTestFile('fileA1.ts');
+    await createTestFile('fileA2.js');
+    await createTestFile('subfolderB', 'fileB1.md');
+
+    const structure = await getFolderStructure(testRootDir);
+    expect(structure.trim()).toBe(
+      `
+Showing up to 20 items (files + folders).
+
+${testRootDir}${path.sep}
+├───fileA1.ts
+├───fileA2.js
+└───subfolderB${path.sep}
+    └───fileB1.md
+`.trim(),
+    );
+  });
+
+  it('should handle an empty folder', async () => {
+    const structure = await getFolderStructure(testRootDir);
+    expect(structure.trim()).toBe(
+      `
+Showing up to 20 items (files + folders).
+
+${testRootDir}${path.sep}
+`
+        .trim()
+        .trim(),
+    );
+  });
+
+  it('should ignore folders specified in ignoredFolders (default)', async () => {
+    await createTestFile('.hiddenfile');
+    await createTestFile('file1.txt');
+    await createEmptyDir('emptyFolder');
+    await createTestFile('node_modules', 'somepackage', 'index.js');
+    await createTestFile('subfolderA', 'fileA1.ts');
+    await createTestFile('subfolderA', 'fileA2.js');
+    await createTestFile('subfolderA', 'subfolderB', 'fileB1.md');
+
+    const structure = await getFolderStructure(testRootDir);
+    expect(structure.trim()).toBe(
+      `
+Showing up to 20 items (files + folders). Folders or files indicated with ... contain more items not shown, were ignored, or the display limit (20 items) was reached.
+
+${testRootDir}${path.sep}
+├───.hiddenfile
+├───file1.txt
+├───emptyFolder${path.sep}
+├───node_modules${path.sep}...
+└───subfolderA${path.sep}
+    ├───fileA1.ts
+    ├───fileA2.js
+    └───subfolderB${path.sep}
+        └───fileB1.md
+`.trim(),
+    );
+  });
+
+  it('should ignore folders specified in custom ignoredFolders', async () => {
+    await createTestFile('.hiddenfile');
+    await createTestFile('file1.txt');
+    await createEmptyDir('emptyFolder');
+    await createTestFile('node_modules', 'somepackage', 'index.js');
+    await createTestFile('subfolderA', 'fileA1.ts');
+
+    const structure = await getFolderStructure(testRootDir, {
+      ignoredFolders: new Set(['subfolderA', 'node_modules']),
+    });
+    const expected = `
+Showing up to 20 items (files + folders). Folders or files indicated with ... contain more items not shown, were ignored, or the display limit (20 items) was reached.
+
+${testRootDir}${path.sep}
+├───.hiddenfile
+├───file1.txt
+├───emptyFolder${path.sep}
+├───node_modules${path.sep}...
+└───subfolderA${path.sep}...
+`.trim();
+    expect(structure.trim()).toBe(expected);
+  });
+
+  it('should filter files by fileIncludePattern', async () => {
+    await createTestFile('fileA1.ts');
+    await createTestFile('fileA2.js');
+    await createTestFile('subfolderB', 'fileB1.md');
+
+    const structure = await getFolderStructure(testRootDir, {
+      fileIncludePattern: /\.ts$/,
+    });
+    const expected = `
+Showing up to 20 items (files + folders).
+
+${testRootDir}${path.sep}
+├───fileA1.ts
+└───subfolderB${path.sep}
+`.trim();
+    expect(structure.trim()).toBe(expected);
+  });
+
+  it('should handle maxItems truncation for files within a folder', async () => {
+    await createTestFile('fileA1.ts');
+    await createTestFile('fileA2.js');
+    await createTestFile('subfolderB', 'fileB1.md');
+
+    const structure = await getFolderStructure(testRootDir, {
+      maxItems: 3,
+    });
+    const expected = `
+Showing up to 3 items (files + folders).
+
+${testRootDir}${path.sep}
+├───fileA1.ts
+├───fileA2.js
+└───subfolderB${path.sep}
+`.trim();
+    expect(structure.trim()).toBe(expected);
+  });
+
+  it('should handle maxItems truncation for subfolders', async () => {
+    for (let i = 0; i < 5; i++) {
+      await createTestFile(`folder-${i}`, 'child.txt');
+    }
+
+    const structure = await getFolderStructure(testRootDir, {
+      maxItems: 4,
+    });
+    const expectedRevised = `
+Showing up to 4 items (files + folders). Folders or files indicated with ... contain more items not shown, were ignored, or the display limit (4 items) was reached.
+
+${testRootDir}${path.sep}
+├───folder-0${path.sep}
+├───folder-1${path.sep}
+├───folder-2${path.sep}
+├───folder-3${path.sep}
+└───...
+`.trim();
+    expect(structure.trim()).toBe(expectedRevised);
+  });
+
+  it('should handle maxItems that only allows the root folder itself', async () => {
+    await createTestFile('fileA1.ts');
+    await createTestFile('fileA2.ts');
+    await createTestFile('subfolderB', 'fileB1.ts');
+
+    const structure = await getFolderStructure(testRootDir, {
+      maxItems: 1,
+    });
+    const expected = `
+Showing up to 1 items (files + folders). Folders or files indicated with ... contain more items not shown, were ignored, or the display limit (1 items) was reached.
+
+${testRootDir}${path.sep}
+├───fileA1.ts
+├───...
+└───...
+`.trim();
+    expect(structure.trim()).toBe(expected);
+  });
+
+  it('should handle non-existent directory', async () => {
+    const nonExistentPath = path.join(testRootDir, 'non-existent');
+    const structure = await getFolderStructure(nonExistentPath);
+    expect(structure).toContain(
+      `Error: Could not read directory "${nonExistentPath}". Check path and permissions.`,
+    );
+  });
+
+  it('should handle deep folder structure within limits', async () => {
+    await createTestFile('level1', 'level2', 'level3', 'file.txt');
+
+    const structure = await getFolderStructure(testRootDir, {
+      maxItems: 10,
+    });
+    const expected = `
+Showing up to 10 items (files + folders).
+
+${testRootDir}${path.sep}
+└───level1${path.sep}
+    └───level2${path.sep}
+        └───level3${path.sep}
+            └───file.txt
+`.trim();
+    expect(structure.trim()).toBe(expected);
+  });
+
+  it('should truncate deep folder structure if maxItems is small', async () => {
+    await createTestFile('level1', 'level2', 'level3', 'file.txt');
+
+    const structure = await getFolderStructure(testRootDir, {
+      maxItems: 3,
+    });
+    const expected = `
+Showing up to 3 items (files + folders).
+
+${testRootDir}${path.sep}
+└───level1${path.sep}
+    └───level2${path.sep}
+        └───level3${path.sep}
+`.trim();
+    expect(structure.trim()).toBe(expected);
+  });
+
+  describe('with gitignore', () => {
+    beforeEach(async () => {
+      await fsPromises.mkdir(path.join(testRootDir, '.git'), {
+        recursive: true,
+      });
+    });
+
+    it('should ignore files and folders specified in .gitignore', async () => {
+      await fsPromises.writeFile(
+        nodePath.join(testRootDir, '.gitignore'),
+        'ignored.txt\nnode_modules/\n.gemini/*\n!/.gemini/config.yaml',
+      );
+      await createTestFile('file1.txt');
+      await createTestFile('node_modules', 'some-package', 'index.js');
+      await createTestFile('ignored.txt');
+      await createTestFile('.gemini', 'config.yaml');
+      await createTestFile('.gemini', 'logs.json');
+
+      const fileService = new FileDiscoveryService(testRootDir);
+      const structure = await getFolderStructure(testRootDir, {
+        fileService,
+      });
+
+      expect(structure).not.toContain('ignored.txt');
+      expect(structure).toContain(`node_modules${path.sep}...`);
+      expect(structure).not.toContain('logs.json');
+      expect(structure).toContain('config.yaml');
+      expect(structure).toContain('file1.txt');
+    });
+
+    it('should not ignore files if respectGitIgnore is false', async () => {
+      await fsPromises.writeFile(
+        nodePath.join(testRootDir, '.gitignore'),
+        'ignored.txt',
+      );
+      await createTestFile('file1.txt');
+      await createTestFile('ignored.txt');
+
+      const fileService = new FileDiscoveryService(testRootDir);
+      const structure = await getFolderStructure(testRootDir, {
+        fileService,
+        fileFilteringOptions: {
+          respectGeminiIgnore: false,
+          respectGitIgnore: false,
+        },
+      });
+
+      expect(structure).toContain('ignored.txt');
+      expect(structure).toContain('file1.txt');
+    });
+  });
+
+  describe('with geminiignore', () => {
+    it('should ignore geminiignore files by default', async () => {
+      await fsPromises.writeFile(
+        nodePath.join(testRootDir, '.geminiignore'),
+        'ignored.txt\nnode_modules/\n.gemini/\n!/.gemini/config.yaml',
+      );
+      await createTestFile('file1.txt');
+      await createTestFile('node_modules', 'some-package', 'index.js');
+      await createTestFile('ignored.txt');
+      await createTestFile('.gemini', 'config.yaml');
+      await createTestFile('.gemini', 'logs.json');
+
+      const fileService = new FileDiscoveryService(testRootDir);
+      const structure = await getFolderStructure(testRootDir, {
+        fileService,
+      });
+      expect(structure).not.toContain('ignored.txt');
+      expect(structure).toContain(`node_modules${path.sep}...`);
+      expect(structure).not.toContain('logs.json');
+    });
+
+    it('should not ignore files if respectGeminiIgnore is false', async () => {
+      await fsPromises.writeFile(
+        nodePath.join(testRootDir, '.geminiignore'),
+        'ignored.txt\nnode_modules/\n.gemini/\n!/.gemini/config.yaml',
+      );
+      await createTestFile('file1.txt');
+      await createTestFile('node_modules', 'some-package', 'index.js');
+      await createTestFile('ignored.txt');
+      await createTestFile('.gemini', 'config.yaml');
+      await createTestFile('.gemini', 'logs.json');
+
+      const fileService = new FileDiscoveryService(testRootDir);
+      const structure = await getFolderStructure(testRootDir, {
+        fileService,
+        fileFilteringOptions: {
+          respectGeminiIgnore: false,
+          respectGitIgnore: true, // Explicitly disable gemini ignore only
+        },
+      });
+      expect(structure).toContain('ignored.txt');
+      // node_modules is still ignored by default
+      expect(structure).toContain(`node_modules${path.sep}...`);
+    });
+  });
+});

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

@@ -0,0 +1,348 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import * as fs from 'fs/promises';
+import { Dirent } from 'fs';
+import * as path from 'path';
+import { getErrorMessage, isNodeError } from './errors.js';
+import { FileDiscoveryService } from '../services/fileDiscoveryService.js';
+import { FileFilteringOptions } from '../config/config.js';
+import { DEFAULT_FILE_FILTERING_OPTIONS } from '../config/config.js';
+
+const MAX_ITEMS = 20;
+const TRUNCATION_INDICATOR = '...';
+const DEFAULT_IGNORED_FOLDERS = new Set(['node_modules', '.git', 'dist']);
+
+// --- Interfaces ---
+
+/** Options for customizing folder structure retrieval. */
+interface FolderStructureOptions {
+  /** Maximum number of files and folders combined to display. Defaults to 20. */
+  maxItems?: number;
+  /** Set of folder names to ignore completely. Case-sensitive. */
+  ignoredFolders?: Set<string>;
+  /** Optional regex to filter included files by name. */
+  fileIncludePattern?: RegExp;
+  /** For filtering files. */
+  fileService?: FileDiscoveryService;
+  /** File filtering ignore options. */
+  fileFilteringOptions?: FileFilteringOptions;
+}
+// Define a type for the merged options where fileIncludePattern remains optional
+type MergedFolderStructureOptions = Required<
+  Omit<FolderStructureOptions, 'fileIncludePattern' | 'fileService'>
+> & {
+  fileIncludePattern?: RegExp;
+  fileService?: FileDiscoveryService;
+  fileFilteringOptions?: FileFilteringOptions;
+};
+
+/** Represents the full, unfiltered information about a folder and its contents. */
+interface FullFolderInfo {
+  name: string;
+  path: string;
+  files: string[];
+  subFolders: FullFolderInfo[];
+  totalChildren: number; // Number of files and subfolders included from this folder during BFS scan
+  totalFiles: number; // Number of files included from this folder during BFS scan
+  isIgnored?: boolean; // Flag to easily identify ignored folders later
+  hasMoreFiles?: boolean; // Indicates if files were truncated for this specific folder
+  hasMoreSubfolders?: boolean; // Indicates if subfolders were truncated for this specific folder
+}
+
+// --- Interfaces ---
+
+// --- Helper Functions ---
+
+async function readFullStructure(
+  rootPath: string,
+  options: MergedFolderStructureOptions,
+): Promise<FullFolderInfo | null> {
+  const rootName = path.basename(rootPath);
+  const rootNode: FullFolderInfo = {
+    name: rootName,
+    path: rootPath,
+    files: [],
+    subFolders: [],
+    totalChildren: 0,
+    totalFiles: 0,
+  };
+
+  const queue: Array<{ folderInfo: FullFolderInfo; currentPath: string }> = [
+    { folderInfo: rootNode, currentPath: rootPath },
+  ];
+  let currentItemCount = 0;
+  // Count the root node itself as one item if we are not just listing its content
+
+  const processedPaths = new Set<string>(); // To avoid processing same path if symlinks create loops
+
+  while (queue.length > 0) {
+    const { folderInfo, currentPath } = queue.shift()!;
+
+    if (processedPaths.has(currentPath)) {
+      continue;
+    }
+    processedPaths.add(currentPath);
+
+    if (currentItemCount >= options.maxItems) {
+      // If the root itself caused us to exceed, we can't really show anything.
+      // Otherwise, this folder won't be processed further.
+      // The parent that queued this would have set its own hasMoreSubfolders flag.
+      continue;
+    }
+
+    let entries: Dirent[];
+    try {
+      const rawEntries = await fs.readdir(currentPath, { withFileTypes: true });
+      // Sort entries alphabetically by name for consistent processing order
+      entries = rawEntries.sort((a, b) => a.name.localeCompare(b.name));
+    } catch (error: unknown) {
+      if (
+        isNodeError(error) &&
+        (error.code === 'EACCES' || error.code === 'ENOENT')
+      ) {
+        console.warn(
+          `Warning: Could not read directory ${currentPath}: ${error.message}`,
+        );
+        if (currentPath === rootPath && error.code === 'ENOENT') {
+          return null; // Root directory itself not found
+        }
+        // For other EACCES/ENOENT on subdirectories, just skip them.
+        continue;
+      }
+      throw error;
+    }
+
+    const filesInCurrentDir: string[] = [];
+    const subFoldersInCurrentDir: FullFolderInfo[] = [];
+
+    // Process files first in the current directory
+    for (const entry of entries) {
+      if (entry.isFile()) {
+        if (currentItemCount >= options.maxItems) {
+          folderInfo.hasMoreFiles = true;
+          break;
+        }
+        const fileName = entry.name;
+        const filePath = path.join(currentPath, fileName);
+        if (options.fileService) {
+          const shouldIgnore =
+            (options.fileFilteringOptions.respectGitIgnore &&
+              options.fileService.shouldGitIgnoreFile(filePath)) ||
+            (options.fileFilteringOptions.respectGeminiIgnore &&
+              options.fileService.shouldGeminiIgnoreFile(filePath));
+          if (shouldIgnore) {
+            continue;
+          }
+        }
+        if (
+          !options.fileIncludePattern ||
+          options.fileIncludePattern.test(fileName)
+        ) {
+          filesInCurrentDir.push(fileName);
+          currentItemCount++;
+          folderInfo.totalFiles++;
+          folderInfo.totalChildren++;
+        }
+      }
+    }
+    folderInfo.files = filesInCurrentDir;
+
+    // Then process directories and queue them
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        // Check if adding this directory ITSELF would meet or exceed maxItems
+        // (currentItemCount refers to items *already* added before this one)
+        if (currentItemCount >= options.maxItems) {
+          folderInfo.hasMoreSubfolders = true;
+          break; // Already at limit, cannot add this folder or any more
+        }
+        // If adding THIS folder makes us hit the limit exactly, and it might have children,
+        // it's better to show '...' for the parent, unless this is the very last item slot.
+        // This logic is tricky. Let's try a simpler: if we can't add this item, mark and break.
+
+        const subFolderName = entry.name;
+        const subFolderPath = path.join(currentPath, subFolderName);
+
+        let isIgnored = false;
+        if (options.fileService) {
+          isIgnored =
+            (options.fileFilteringOptions.respectGitIgnore &&
+              options.fileService.shouldGitIgnoreFile(subFolderPath)) ||
+            (options.fileFilteringOptions.respectGeminiIgnore &&
+              options.fileService.shouldGeminiIgnoreFile(subFolderPath));
+        }
+
+        if (options.ignoredFolders.has(subFolderName) || isIgnored) {
+          const ignoredSubFolder: FullFolderInfo = {
+            name: subFolderName,
+            path: subFolderPath,
+            files: [],
+            subFolders: [],
+            totalChildren: 0,
+            totalFiles: 0,
+            isIgnored: true,
+          };
+          subFoldersInCurrentDir.push(ignoredSubFolder);
+          currentItemCount++; // Count the ignored folder itself
+          folderInfo.totalChildren++; // Also counts towards parent's children
+          continue;
+        }
+
+        const subFolderNode: FullFolderInfo = {
+          name: subFolderName,
+          path: subFolderPath,
+          files: [],
+          subFolders: [],
+          totalChildren: 0,
+          totalFiles: 0,
+        };
+        subFoldersInCurrentDir.push(subFolderNode);
+        currentItemCount++;
+        folderInfo.totalChildren++; // Counts towards parent's children
+
+        // Add to queue for processing its children later
+        queue.push({ folderInfo: subFolderNode, currentPath: subFolderPath });
+      }
+    }
+    folderInfo.subFolders = subFoldersInCurrentDir;
+  }
+
+  return rootNode;
+}
+
+/**
+ * Reads the directory structure using BFS, respecting maxItems.
+ * @param node The current node in the reduced structure.
+ * @param indent The current indentation string.
+ * @param isLast Sibling indicator.
+ * @param builder Array to build the string lines.
+ */
+function formatStructure(
+  node: FullFolderInfo,
+  currentIndent: string,
+  isLastChildOfParent: boolean,
+  isProcessingRootNode: boolean,
+  builder: string[],
+): void {
+  const connector = isLastChildOfParent ? '└───' : '├───';
+
+  // The root node of the structure (the one passed initially to getFolderStructure)
+  // is not printed with a connector line itself, only its name as a header.
+  // Its children are printed relative to that conceptual root.
+  // Ignored root nodes ARE printed with a connector.
+  if (!isProcessingRootNode || node.isIgnored) {
+    builder.push(
+      `${currentIndent}${connector}${node.name}${path.sep}${node.isIgnored ? TRUNCATION_INDICATOR : ''}`,
+    );
+  }
+
+  // Determine the indent for the children of *this* node.
+  // If *this* node was the root of the whole structure, its children start with no indent before their connectors.
+  // Otherwise, children's indent extends from the current node's indent.
+  const indentForChildren = isProcessingRootNode
+    ? ''
+    : currentIndent + (isLastChildOfParent ? '    ' : '│   ');
+
+  // Render files of the current node
+  const fileCount = node.files.length;
+  for (let i = 0; i < fileCount; i++) {
+    const isLastFileAmongSiblings =
+      i === fileCount - 1 &&
+      node.subFolders.length === 0 &&
+      !node.hasMoreSubfolders;
+    const fileConnector = isLastFileAmongSiblings ? '└───' : '├───';
+    builder.push(`${indentForChildren}${fileConnector}${node.files[i]}`);
+  }
+  if (node.hasMoreFiles) {
+    const isLastIndicatorAmongSiblings =
+      node.subFolders.length === 0 && !node.hasMoreSubfolders;
+    const fileConnector = isLastIndicatorAmongSiblings ? '└───' : '├───';
+    builder.push(`${indentForChildren}${fileConnector}${TRUNCATION_INDICATOR}`);
+  }
+
+  // Render subfolders of the current node
+  const subFolderCount = node.subFolders.length;
+  for (let i = 0; i < subFolderCount; i++) {
+    const isLastSubfolderAmongSiblings =
+      i === subFolderCount - 1 && !node.hasMoreSubfolders;
+    // Children are never the root node being processed initially.
+    formatStructure(
+      node.subFolders[i],
+      indentForChildren,
+      isLastSubfolderAmongSiblings,
+      false,
+      builder,
+    );
+  }
+  if (node.hasMoreSubfolders) {
+    builder.push(`${indentForChildren}└───${TRUNCATION_INDICATOR}`);
+  }
+}
+
+// --- Main Exported Function ---
+
+/**
+ * Generates a string representation of a directory's structure,
+ * limiting the number of items displayed. Ignored folders are shown
+ * followed by '...' instead of their contents.
+ *
+ * @param directory The absolute or relative path to the directory.
+ * @param options Optional configuration settings.
+ * @returns A promise resolving to the formatted folder structure string.
+ */
+export async function getFolderStructure(
+  directory: string,
+  options?: FolderStructureOptions,
+): Promise<string> {
+  const resolvedPath = path.resolve(directory);
+  const mergedOptions: MergedFolderStructureOptions = {
+    maxItems: options?.maxItems ?? MAX_ITEMS,
+    ignoredFolders: options?.ignoredFolders ?? DEFAULT_IGNORED_FOLDERS,
+    fileIncludePattern: options?.fileIncludePattern,
+    fileService: options?.fileService,
+    fileFilteringOptions:
+      options?.fileFilteringOptions ?? DEFAULT_FILE_FILTERING_OPTIONS,
+  };
+
+  try {
+    // 1. Read the structure using BFS, respecting maxItems
+    const structureRoot = await readFullStructure(resolvedPath, mergedOptions);
+
+    if (!structureRoot) {
+      return `Error: Could not read directory "${resolvedPath}". Check path and permissions.`;
+    }
+
+    // 2. Format the structure into a string
+    const structureLines: string[] = [];
+    // Pass true for isRoot for the initial call
+    formatStructure(structureRoot, '', true, true, structureLines);
+
+    // 3. Build the final output string
+    function isTruncated(node: FullFolderInfo): boolean {
+      if (node.hasMoreFiles || node.hasMoreSubfolders || node.isIgnored) {
+        return true;
+      }
+      for (const sub of node.subFolders) {
+        if (isTruncated(sub)) {
+          return true;
+        }
+      }
+      return false;
+    }
+
+    let summary = `Showing up to ${mergedOptions.maxItems} items (files + folders).`;
+
+    if (isTruncated(structureRoot)) {
+      summary += ` Folders or files indicated with ${TRUNCATION_INDICATOR} contain more items not shown, were ignored, or the display limit (${mergedOptions.maxItems} items) was reached.`;
+    }
+
+    return `${summary}\n\n${resolvedPath}${path.sep}\n${structureLines.join('\n')}`;
+  } catch (error: unknown) {
+    console.error(`Error getting folder structure for ${resolvedPath}:`, error);
+    return `Error processing directory "${resolvedPath}": ${getErrorMessage(error)}`;
+  }
+}

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

@@ -0,0 +1,34 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+export type PtyImplementation = {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  module: any;
+  name: 'lydell-node-pty' | 'node-pty';
+} | null;
+
+export interface PtyProcess {
+  readonly pid: number;
+  onData(callback: (data: string) => void): void;
+  onExit(callback: (e: { exitCode: number; signal?: number }) => void): void;
+  kill(signal?: string): void;
+}
+
+export const getPty = async (): Promise<PtyImplementation> => {
+  try {
+    const lydell = '@lydell/node-pty';
+    const module = await import(lydell);
+    return { module, name: 'lydell-node-pty' };
+  } catch (_e) {
+    try {
+      const nodePty = 'node-pty';
+      const module = await import(nodePty);
+      return { module, name: 'node-pty' };
+    } catch (_e2) {
+      return null;
+    }
+  }
+};

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

@@ -0,0 +1,196 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { GitIgnoreParser } from './gitIgnoreParser.js';
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import * as os from 'os';
+
+describe('GitIgnoreParser', () => {
+  let parser: GitIgnoreParser;
+  let projectRoot: string;
+
+  async function createTestFile(filePath: string, content = '') {
+    const fullPath = path.join(projectRoot, filePath);
+    await fs.mkdir(path.dirname(fullPath), { recursive: true });
+    await fs.writeFile(fullPath, content);
+  }
+
+  async function setupGitRepo() {
+    await fs.mkdir(path.join(projectRoot, '.git'), { recursive: true });
+  }
+
+  beforeEach(async () => {
+    projectRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'gitignore-test-'));
+    parser = new GitIgnoreParser(projectRoot);
+  });
+
+  afterEach(async () => {
+    await fs.rm(projectRoot, { recursive: true, force: true });
+  });
+
+  describe('initialization', () => {
+    it('should initialize without errors when no .gitignore exists', async () => {
+      await setupGitRepo();
+      expect(() => parser.loadGitRepoPatterns()).not.toThrow();
+    });
+
+    it('should load .gitignore patterns when file exists', async () => {
+      await setupGitRepo();
+      const gitignoreContent = `
+# Comment
+node_modules/
+*.log
+/dist
+.env
+`;
+      await createTestFile('.gitignore', gitignoreContent);
+
+      parser.loadGitRepoPatterns();
+
+      expect(parser.getPatterns()).toEqual([
+        '.git',
+        'node_modules/',
+        '*.log',
+        '/dist',
+        '.env',
+      ]);
+      expect(parser.isIgnored(path.join('node_modules', 'some-lib'))).toBe(
+        true,
+      );
+      expect(parser.isIgnored(path.join('src', 'app.log'))).toBe(true);
+      expect(parser.isIgnored(path.join('dist', 'index.js'))).toBe(true);
+      expect(parser.isIgnored('.env')).toBe(true);
+    });
+
+    it('should handle git exclude file', async () => {
+      await setupGitRepo();
+      await createTestFile(
+        path.join('.git', 'info', 'exclude'),
+        'temp/\n*.tmp',
+      );
+
+      parser.loadGitRepoPatterns();
+      expect(parser.getPatterns()).toEqual(['.git', 'temp/', '*.tmp']);
+      expect(parser.isIgnored(path.join('temp', 'file.txt'))).toBe(true);
+      expect(parser.isIgnored(path.join('src', 'file.tmp'))).toBe(true);
+    });
+
+    it('should handle custom patterns file name', async () => {
+      // No .git directory for this test
+      await createTestFile('.geminiignore', 'temp/\n*.tmp');
+
+      parser.loadPatterns('.geminiignore');
+      expect(parser.getPatterns()).toEqual(['temp/', '*.tmp']);
+      expect(parser.isIgnored(path.join('temp', 'file.txt'))).toBe(true);
+      expect(parser.isIgnored(path.join('src', 'file.tmp'))).toBe(true);
+    });
+
+    it('should initialize without errors when no .geminiignore exists', () => {
+      expect(() => parser.loadPatterns('.geminiignore')).not.toThrow();
+    });
+  });
+
+  describe('isIgnored', () => {
+    beforeEach(async () => {
+      await setupGitRepo();
+      const gitignoreContent = `
+node_modules/
+*.log
+/dist
+/.env
+src/*.tmp
+!src/important.tmp
+`;
+      await createTestFile('.gitignore', gitignoreContent);
+      parser.loadGitRepoPatterns();
+    });
+
+    it('should always ignore .git directory', () => {
+      expect(parser.isIgnored('.git')).toBe(true);
+      expect(parser.isIgnored(path.join('.git', 'config'))).toBe(true);
+      expect(parser.isIgnored(path.join(projectRoot, '.git', 'HEAD'))).toBe(
+        true,
+      );
+    });
+
+    it('should ignore files matching patterns', () => {
+      expect(
+        parser.isIgnored(path.join('node_modules', 'package', 'index.js')),
+      ).toBe(true);
+      expect(parser.isIgnored('app.log')).toBe(true);
+      expect(parser.isIgnored(path.join('logs', 'app.log'))).toBe(true);
+      expect(parser.isIgnored(path.join('dist', 'bundle.js'))).toBe(true);
+      expect(parser.isIgnored('.env')).toBe(true);
+      expect(parser.isIgnored(path.join('config', '.env'))).toBe(false); // .env is anchored to root
+    });
+
+    it('should ignore files with path-specific patterns', () => {
+      expect(parser.isIgnored(path.join('src', 'temp.tmp'))).toBe(true);
+      expect(parser.isIgnored(path.join('other', 'temp.tmp'))).toBe(false);
+    });
+
+    it('should handle negation patterns', () => {
+      expect(parser.isIgnored(path.join('src', 'important.tmp'))).toBe(false);
+    });
+
+    it('should not ignore files that do not match patterns', () => {
+      expect(parser.isIgnored(path.join('src', 'index.ts'))).toBe(false);
+      expect(parser.isIgnored('README.md')).toBe(false);
+    });
+
+    it('should handle absolute paths correctly', () => {
+      const absolutePath = path.join(projectRoot, 'node_modules', 'lib');
+      expect(parser.isIgnored(absolutePath)).toBe(true);
+    });
+
+    it('should handle paths outside project root by not ignoring them', () => {
+      const outsidePath = path.resolve(projectRoot, '..', 'other', 'file.txt');
+      expect(parser.isIgnored(outsidePath)).toBe(false);
+    });
+
+    it('should handle relative paths correctly', () => {
+      expect(parser.isIgnored(path.join('node_modules', 'some-package'))).toBe(
+        true,
+      );
+      expect(
+        parser.isIgnored(path.join('..', 'some', 'other', 'file.txt')),
+      ).toBe(false);
+    });
+
+    it('should normalize path separators on Windows', () => {
+      expect(parser.isIgnored(path.join('node_modules', 'package'))).toBe(true);
+      expect(parser.isIgnored(path.join('src', 'temp.tmp'))).toBe(true);
+    });
+
+    it('should handle root path "/" without throwing error', () => {
+      expect(() => parser.isIgnored('/')).not.toThrow();
+      expect(parser.isIgnored('/')).toBe(false);
+    });
+
+    it('should handle absolute-like paths without throwing error', () => {
+      expect(() => parser.isIgnored('/some/path')).not.toThrow();
+      expect(parser.isIgnored('/some/path')).toBe(false);
+    });
+
+    it('should handle paths that start with forward slash', () => {
+      expect(() => parser.isIgnored('/node_modules')).not.toThrow();
+      expect(parser.isIgnored('/node_modules')).toBe(false);
+    });
+  });
+
+  describe('getIgnoredPatterns', () => {
+    it('should return the raw patterns added', async () => {
+      await setupGitRepo();
+      const gitignoreContent = '*.log\n!important.log';
+      await createTestFile('.gitignore', gitignoreContent);
+
+      parser.loadGitRepoPatterns();
+      expect(parser.getPatterns()).toEqual(['.git', '*.log', '!important.log']);
+    });
+  });
+});