Add files using upload-large-folder tool

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

@@ -0,0 +1,75 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+import ignore, { type Ignore } from 'ignore';
+import { isGitRepository } from './gitUtils.js';
+
+export interface GitIgnoreFilter {
+  isIgnored(filePath: string): boolean;
+  getPatterns(): string[];
+}
+
+export class GitIgnoreParser implements GitIgnoreFilter {
+  private projectRoot: string;
+  private ig: Ignore = ignore();
+  private patterns: string[] = [];
+
+  constructor(projectRoot: string) {
+    this.projectRoot = path.resolve(projectRoot);
+  }
+
+  loadGitRepoPatterns(): void {
+    if (!isGitRepository(this.projectRoot)) return;
+
+    // Always ignore .git directory regardless of .gitignore content
+    this.addPatterns(['.git']);
+
+    const patternFiles = ['.gitignore', path.join('.git', 'info', 'exclude')];
+    for (const pf of patternFiles) {
+      this.loadPatterns(pf);
+    }
+  }
+
+  loadPatterns(patternsFileName: string): void {
+    const patternsFilePath = path.join(this.projectRoot, patternsFileName);
+    let content: string;
+    try {
+      content = fs.readFileSync(patternsFilePath, 'utf-8');
+    } catch (_error) {
+      // ignore file not found
+      return;
+    }
+    const patterns = (content ?? '')
+      .split('\n')
+      .map((p) => p.trim())
+      .filter((p) => p !== '' && !p.startsWith('#'));
+    this.addPatterns(patterns);
+  }
+
+  private addPatterns(patterns: string[]) {
+    this.ig.add(patterns);
+    this.patterns.push(...patterns);
+  }
+
+  isIgnored(filePath: string): boolean {
+    const resolved = path.resolve(this.projectRoot, filePath);
+    const relativePath = path.relative(this.projectRoot, resolved);
+
+    if (relativePath === '' || relativePath.startsWith('..')) {
+      return false;
+    }
+
+    // Even in windows, Ignore expects forward slashes.
+    const normalizedPath = relativePath.replace(/\\/g, '/');
+    return this.ig.ignores(normalizedPath);
+  }
+
+  getPatterns(): string[] {
+    return this.patterns;
+  }
+}

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

@@ -0,0 +1,73 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+
+/**
+ * Checks if a directory is within a git repository
+ * @param directory The directory to check
+ * @returns true if the directory is in a git repository, false otherwise
+ */
+export function isGitRepository(directory: string): boolean {
+  try {
+    let currentDir = path.resolve(directory);
+
+    while (true) {
+      const gitDir = path.join(currentDir, '.git');
+
+      // Check if .git exists (either as directory or file for worktrees)
+      if (fs.existsSync(gitDir)) {
+        return true;
+      }
+
+      const parentDir = path.dirname(currentDir);
+
+      // If we've reached the root directory, stop searching
+      if (parentDir === currentDir) {
+        break;
+      }
+
+      currentDir = parentDir;
+    }
+
+    return false;
+  } catch (_error) {
+    // If any filesystem error occurs, assume not a git repo
+    return false;
+  }
+}
+
+/**
+ * Finds the root directory of a git repository
+ * @param directory Starting directory to search from
+ * @returns The git repository root path, or null if not in a git repository
+ */
+export function findGitRoot(directory: string): string | null {
+  try {
+    let currentDir = path.resolve(directory);
+
+    while (true) {
+      const gitDir = path.join(currentDir, '.git');
+
+      if (fs.existsSync(gitDir)) {
+        return currentDir;
+      }
+
+      const parentDir = path.dirname(currentDir);
+
+      if (parentDir === currentDir) {
+        break;
+      }
+
+      currentDir = parentDir;
+    }
+
+    return null;
+  } catch (_error) {
+    return null;
+  }
+}

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

@@ -0,0 +1,371 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { vi, describe, it, expect, beforeEach, afterEach } from 'vitest';
+import * as fsPromises from 'fs/promises';
+import * as os from 'os';
+import * as path from 'path';
+import { loadServerHierarchicalMemory } from './memoryDiscovery.js';
+import {
+  GEMINI_CONFIG_DIR,
+  setGeminiMdFilename,
+  DEFAULT_CONTEXT_FILENAME,
+} from '../tools/memoryTool.js';
+import { FileDiscoveryService } from '../services/fileDiscoveryService.js';
+
+vi.mock('os', async (importOriginal) => {
+  const actualOs = await importOriginal<typeof os>();
+  return {
+    ...actualOs,
+    homedir: vi.fn(),
+  };
+});
+
+describe('loadServerHierarchicalMemory', () => {
+  let testRootDir: string;
+  let cwd: string;
+  let projectRoot: string;
+  let homedir: string;
+
+  async function createEmptyDir(fullPath: string) {
+    await fsPromises.mkdir(fullPath, { recursive: true });
+    return fullPath;
+  }
+
+  async function createTestFile(fullPath: string, fileContents: string) {
+    await fsPromises.mkdir(path.dirname(fullPath), { recursive: true });
+    await fsPromises.writeFile(fullPath, fileContents);
+    return path.resolve(testRootDir, fullPath);
+  }
+
+  beforeEach(async () => {
+    testRootDir = await fsPromises.mkdtemp(
+      path.join(os.tmpdir(), 'folder-structure-test-'),
+    );
+
+    vi.resetAllMocks();
+    // Set environment variables to indicate test environment
+    vi.stubEnv('NODE_ENV', 'test');
+    vi.stubEnv('VITEST', 'true');
+
+    projectRoot = await createEmptyDir(path.join(testRootDir, 'project'));
+    cwd = await createEmptyDir(path.join(projectRoot, 'src'));
+    homedir = await createEmptyDir(path.join(testRootDir, 'userhome'));
+    vi.mocked(os.homedir).mockReturnValue(homedir);
+  });
+
+  afterEach(async () => {
+    vi.unstubAllEnvs();
+    // Some tests set this to a different value.
+    setGeminiMdFilename(DEFAULT_CONTEXT_FILENAME);
+    // Clean up the temporary directory to prevent resource leaks.
+    await fsPromises.rm(testRootDir, { recursive: true, force: true });
+  });
+
+  it('should return empty memory and count if no context files are found', async () => {
+    const result = await loadServerHierarchicalMemory(
+      cwd,
+      [],
+      false,
+      new FileDiscoveryService(projectRoot),
+    );
+
+    expect(result).toEqual({
+      memoryContent: '',
+      fileCount: 0,
+    });
+  });
+
+  it('should load only the global context file if present and others are not (default filename)', async () => {
+    const defaultContextFile = await createTestFile(
+      path.join(homedir, GEMINI_CONFIG_DIR, DEFAULT_CONTEXT_FILENAME),
+      'default context content',
+    );
+
+    const result = await loadServerHierarchicalMemory(
+      cwd,
+      [],
+      false,
+      new FileDiscoveryService(projectRoot),
+    );
+
+    expect(result).toEqual({
+      memoryContent: `--- Context from: ${path.relative(cwd, defaultContextFile)} ---\ndefault context content\n--- End of Context from: ${path.relative(cwd, defaultContextFile)} ---`,
+      fileCount: 1,
+    });
+  });
+
+  it('should load only the global custom context file if present and filename is changed', async () => {
+    const customFilename = 'CUSTOM_AGENTS.md';
+    setGeminiMdFilename(customFilename);
+
+    const customContextFile = await createTestFile(
+      path.join(homedir, GEMINI_CONFIG_DIR, customFilename),
+      'custom context content',
+    );
+
+    const result = await loadServerHierarchicalMemory(
+      cwd,
+      [],
+      false,
+      new FileDiscoveryService(projectRoot),
+    );
+
+    expect(result).toEqual({
+      memoryContent: `--- Context from: ${path.relative(cwd, customContextFile)} ---\ncustom context content\n--- End of Context from: ${path.relative(cwd, customContextFile)} ---`,
+      fileCount: 1,
+    });
+  });
+
+  it('should load context files by upward traversal with custom filename', async () => {
+    const customFilename = 'PROJECT_CONTEXT.md';
+    setGeminiMdFilename(customFilename);
+
+    const projectContextFile = await createTestFile(
+      path.join(projectRoot, customFilename),
+      'project context content',
+    );
+    const cwdContextFile = await createTestFile(
+      path.join(cwd, customFilename),
+      'cwd context content',
+    );
+
+    const result = await loadServerHierarchicalMemory(
+      cwd,
+      [],
+      false,
+      new FileDiscoveryService(projectRoot),
+    );
+
+    expect(result).toEqual({
+      memoryContent: `--- Context from: ${path.relative(cwd, projectContextFile)} ---\nproject context content\n--- End of Context from: ${path.relative(cwd, projectContextFile)} ---\n\n--- Context from: ${path.relative(cwd, cwdContextFile)} ---\ncwd context content\n--- End of Context from: ${path.relative(cwd, cwdContextFile)} ---`,
+      fileCount: 2,
+    });
+  });
+
+  it('should load context files by downward traversal with custom filename', async () => {
+    const customFilename = 'LOCAL_CONTEXT.md';
+    setGeminiMdFilename(customFilename);
+
+    await createTestFile(
+      path.join(cwd, 'subdir', customFilename),
+      'Subdir custom memory',
+    );
+    await createTestFile(path.join(cwd, customFilename), 'CWD custom memory');
+
+    const result = await loadServerHierarchicalMemory(
+      cwd,
+      [],
+      false,
+      new FileDiscoveryService(projectRoot),
+    );
+
+    expect(result).toEqual({
+      memoryContent: `--- Context from: ${customFilename} ---\nCWD custom memory\n--- End of Context from: ${customFilename} ---\n\n--- Context from: ${path.join('subdir', customFilename)} ---\nSubdir custom memory\n--- End of Context from: ${path.join('subdir', customFilename)} ---`,
+      fileCount: 2,
+    });
+  });
+
+  it('should load ORIGINAL_GEMINI_MD_FILENAME files by upward traversal from CWD to project root', async () => {
+    const projectRootGeminiFile = await createTestFile(
+      path.join(projectRoot, DEFAULT_CONTEXT_FILENAME),
+      'Project root memory',
+    );
+    const srcGeminiFile = await createTestFile(
+      path.join(cwd, DEFAULT_CONTEXT_FILENAME),
+      'Src directory memory',
+    );
+
+    const result = await loadServerHierarchicalMemory(
+      cwd,
+      [],
+      false,
+      new FileDiscoveryService(projectRoot),
+    );
+
+    expect(result).toEqual({
+      memoryContent: `--- Context from: ${path.relative(cwd, projectRootGeminiFile)} ---\nProject root memory\n--- End of Context from: ${path.relative(cwd, projectRootGeminiFile)} ---\n\n--- Context from: ${path.relative(cwd, srcGeminiFile)} ---\nSrc directory memory\n--- End of Context from: ${path.relative(cwd, srcGeminiFile)} ---`,
+      fileCount: 2,
+    });
+  });
+
+  it('should load ORIGINAL_GEMINI_MD_FILENAME files by downward traversal from CWD', async () => {
+    await createTestFile(
+      path.join(cwd, 'subdir', DEFAULT_CONTEXT_FILENAME),
+      'Subdir memory',
+    );
+    await createTestFile(
+      path.join(cwd, DEFAULT_CONTEXT_FILENAME),
+      'CWD memory',
+    );
+
+    const result = await loadServerHierarchicalMemory(
+      cwd,
+      [],
+      false,
+      new FileDiscoveryService(projectRoot),
+    );
+
+    expect(result).toEqual({
+      memoryContent: `--- Context from: ${DEFAULT_CONTEXT_FILENAME} ---\nCWD memory\n--- End of Context from: ${DEFAULT_CONTEXT_FILENAME} ---\n\n--- Context from: ${path.join('subdir', DEFAULT_CONTEXT_FILENAME)} ---\nSubdir memory\n--- End of Context from: ${path.join('subdir', DEFAULT_CONTEXT_FILENAME)} ---`,
+      fileCount: 2,
+    });
+  });
+
+  it('should load and correctly order global, upward, and downward ORIGINAL_GEMINI_MD_FILENAME files', async () => {
+    const defaultContextFile = await createTestFile(
+      path.join(homedir, GEMINI_CONFIG_DIR, DEFAULT_CONTEXT_FILENAME),
+      'default context content',
+    );
+    const rootGeminiFile = await createTestFile(
+      path.join(testRootDir, DEFAULT_CONTEXT_FILENAME),
+      'Project parent memory',
+    );
+    const projectRootGeminiFile = await createTestFile(
+      path.join(projectRoot, DEFAULT_CONTEXT_FILENAME),
+      'Project root memory',
+    );
+    const cwdGeminiFile = await createTestFile(
+      path.join(cwd, DEFAULT_CONTEXT_FILENAME),
+      'CWD memory',
+    );
+    const subDirGeminiFile = await createTestFile(
+      path.join(cwd, 'sub', DEFAULT_CONTEXT_FILENAME),
+      'Subdir memory',
+    );
+
+    const result = await loadServerHierarchicalMemory(
+      cwd,
+      [],
+      false,
+      new FileDiscoveryService(projectRoot),
+    );
+
+    expect(result).toEqual({
+      memoryContent: `--- Context from: ${path.relative(cwd, defaultContextFile)} ---\ndefault context content\n--- End of Context from: ${path.relative(cwd, defaultContextFile)} ---\n\n--- Context from: ${path.relative(cwd, rootGeminiFile)} ---\nProject parent memory\n--- End of Context from: ${path.relative(cwd, rootGeminiFile)} ---\n\n--- Context from: ${path.relative(cwd, projectRootGeminiFile)} ---\nProject root memory\n--- End of Context from: ${path.relative(cwd, projectRootGeminiFile)} ---\n\n--- Context from: ${path.relative(cwd, cwdGeminiFile)} ---\nCWD memory\n--- End of Context from: ${path.relative(cwd, cwdGeminiFile)} ---\n\n--- Context from: ${path.relative(cwd, subDirGeminiFile)} ---\nSubdir memory\n--- End of Context from: ${path.relative(cwd, subDirGeminiFile)} ---`,
+      fileCount: 5,
+    });
+  });
+
+  it('should ignore specified directories during downward scan', async () => {
+    await createEmptyDir(path.join(projectRoot, '.git'));
+    await createTestFile(path.join(projectRoot, '.gitignore'), 'node_modules');
+
+    await createTestFile(
+      path.join(cwd, 'node_modules', DEFAULT_CONTEXT_FILENAME),
+      'Ignored memory',
+    );
+    const regularSubDirGeminiFile = await createTestFile(
+      path.join(cwd, 'my_code', DEFAULT_CONTEXT_FILENAME),
+      'My code memory',
+    );
+
+    const result = await loadServerHierarchicalMemory(
+      cwd,
+      [],
+      false,
+      new FileDiscoveryService(projectRoot),
+      [],
+      'tree',
+      {
+        respectGitIgnore: true,
+        respectGeminiIgnore: true,
+      },
+      200, // maxDirs parameter
+    );
+
+    expect(result).toEqual({
+      memoryContent: `--- Context from: ${path.relative(cwd, regularSubDirGeminiFile)} ---\nMy code memory\n--- End of Context from: ${path.relative(cwd, regularSubDirGeminiFile)} ---`,
+      fileCount: 1,
+    });
+  });
+
+  it('should respect the maxDirs parameter during downward scan', async () => {
+    const consoleDebugSpy = vi
+      .spyOn(console, 'debug')
+      .mockImplementation(() => {});
+
+    for (let i = 0; i < 100; i++) {
+      await createEmptyDir(path.join(cwd, `deep_dir_${i}`));
+    }
+
+    // Pass the custom limit directly to the function
+    await loadServerHierarchicalMemory(
+      cwd,
+      [],
+      true,
+      new FileDiscoveryService(projectRoot),
+      [],
+      'tree', // importFormat
+      {
+        respectGitIgnore: true,
+        respectGeminiIgnore: true,
+      },
+      50, // maxDirs
+    );
+
+    expect(consoleDebugSpy).toHaveBeenCalledWith(
+      expect.stringContaining('[DEBUG] [BfsFileSearch]'),
+      expect.stringContaining('Scanning [50/50]:'),
+    );
+
+    vi.mocked(console.debug).mockRestore();
+
+    const result = await loadServerHierarchicalMemory(
+      cwd,
+      [],
+      false,
+      new FileDiscoveryService(projectRoot),
+    );
+
+    expect(result).toEqual({
+      memoryContent: '',
+      fileCount: 0,
+    });
+  });
+
+  it('should load extension context file paths', async () => {
+    const extensionFilePath = await createTestFile(
+      path.join(testRootDir, 'extensions/ext1/QWEN.md'),
+      'Extension memory content',
+    );
+
+    const result = await loadServerHierarchicalMemory(
+      cwd,
+      [],
+      false,
+      new FileDiscoveryService(projectRoot),
+      [extensionFilePath],
+    );
+
+    expect(result).toEqual({
+      memoryContent: `--- Context from: ${path.relative(cwd, extensionFilePath)} ---\nExtension memory content\n--- End of Context from: ${path.relative(cwd, extensionFilePath)} ---`,
+      fileCount: 1,
+    });
+  });
+
+  it('should load memory from included directories', async () => {
+    const includedDir = await createEmptyDir(
+      path.join(testRootDir, 'included'),
+    );
+    const includedFile = await createTestFile(
+      path.join(includedDir, DEFAULT_CONTEXT_FILENAME),
+      'included directory memory',
+    );
+
+    const result = await loadServerHierarchicalMemory(
+      cwd,
+      [includedDir],
+      false,
+      new FileDiscoveryService(projectRoot),
+    );
+
+    expect(result).toEqual({
+      memoryContent: `--- Context from: ${path.relative(cwd, includedFile)} ---\nincluded directory memory\n--- End of Context from: ${path.relative(cwd, includedFile)} ---`,
+      fileCount: 1,
+    });
+  });
+});

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

@@ -0,0 +1,363 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import * as fs from 'fs/promises';
+import * as fsSync from 'fs';
+import * as path from 'path';
+import { homedir } from 'os';
+import { bfsFileSearch } from './bfsFileSearch.js';
+import {
+  GEMINI_CONFIG_DIR,
+  getAllGeminiMdFilenames,
+} from '../tools/memoryTool.js';
+import { FileDiscoveryService } from '../services/fileDiscoveryService.js';
+import { processImports } from './memoryImportProcessor.js';
+import {
+  DEFAULT_MEMORY_FILE_FILTERING_OPTIONS,
+  FileFilteringOptions,
+} from '../config/config.js';
+
+// Simple console logger, similar to the one previously in CLI's config.ts
+// TODO: Integrate with a more robust server-side logger if available/appropriate.
+const logger = {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  debug: (...args: any[]) =>
+    console.debug('[DEBUG] [MemoryDiscovery]', ...args),
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  warn: (...args: any[]) => console.warn('[WARN] [MemoryDiscovery]', ...args),
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  error: (...args: any[]) =>
+    console.error('[ERROR] [MemoryDiscovery]', ...args),
+};
+
+interface GeminiFileContent {
+  filePath: string;
+  content: string | null;
+}
+
+async function findProjectRoot(startDir: string): Promise<string | null> {
+  let currentDir = path.resolve(startDir);
+  while (true) {
+    const gitPath = path.join(currentDir, '.git');
+    try {
+      const stats = await fs.lstat(gitPath);
+      if (stats.isDirectory()) {
+        return currentDir;
+      }
+    } catch (error: unknown) {
+      // Don't log ENOENT errors as they're expected when .git doesn't exist
+      // Also don't log errors in test environments, which often have mocked fs
+      const isENOENT =
+        typeof error === 'object' &&
+        error !== null &&
+        'code' in error &&
+        (error as { code: string }).code === 'ENOENT';
+
+      // Only log unexpected errors in non-test environments
+      // process.env['NODE_ENV'] === 'test' or VITEST are common test indicators
+      const isTestEnv =
+        process.env['NODE_ENV'] === 'test' || process.env['VITEST'];
+
+      if (!isENOENT && !isTestEnv) {
+        if (typeof error === 'object' && error !== null && 'code' in error) {
+          const fsError = error as { code: string; message: string };
+          logger.warn(
+            `Error checking for .git directory at ${gitPath}: ${fsError.message}`,
+          );
+        } else {
+          logger.warn(
+            `Non-standard error checking for .git directory at ${gitPath}: ${String(error)}`,
+          );
+        }
+      }
+    }
+    const parentDir = path.dirname(currentDir);
+    if (parentDir === currentDir) {
+      return null;
+    }
+    currentDir = parentDir;
+  }
+}
+
+async function getGeminiMdFilePathsInternal(
+  currentWorkingDirectory: string,
+  includeDirectoriesToReadGemini: readonly string[],
+  userHomePath: string,
+  debugMode: boolean,
+  fileService: FileDiscoveryService,
+  extensionContextFilePaths: string[] = [],
+  fileFilteringOptions: FileFilteringOptions,
+  maxDirs: number,
+): Promise<string[]> {
+  const dirs = new Set<string>([
+    ...includeDirectoriesToReadGemini,
+    currentWorkingDirectory,
+  ]);
+  const paths = [];
+  for (const dir of dirs) {
+    const pathsByDir = await getGeminiMdFilePathsInternalForEachDir(
+      dir,
+      userHomePath,
+      debugMode,
+      fileService,
+      extensionContextFilePaths,
+      fileFilteringOptions,
+      maxDirs,
+    );
+    paths.push(...pathsByDir);
+  }
+  return Array.from(new Set<string>(paths));
+}
+
+async function getGeminiMdFilePathsInternalForEachDir(
+  dir: string,
+  userHomePath: string,
+  debugMode: boolean,
+  fileService: FileDiscoveryService,
+  extensionContextFilePaths: string[] = [],
+  fileFilteringOptions: FileFilteringOptions,
+  maxDirs: number,
+): Promise<string[]> {
+  const allPaths = new Set<string>();
+  const geminiMdFilenames = getAllGeminiMdFilenames();
+
+  for (const geminiMdFilename of geminiMdFilenames) {
+    const resolvedHome = path.resolve(userHomePath);
+    const globalMemoryPath = path.join(
+      resolvedHome,
+      GEMINI_CONFIG_DIR,
+      geminiMdFilename,
+    );
+
+    // This part that finds the global file always runs.
+    try {
+      await fs.access(globalMemoryPath, fsSync.constants.R_OK);
+      allPaths.add(globalMemoryPath);
+      if (debugMode)
+        logger.debug(
+          `Found readable global ${geminiMdFilename}: ${globalMemoryPath}`,
+        );
+    } catch {
+      // It's okay if it's not found.
+    }
+
+    // Handle the case where we're in the home directory (dir is empty string or home path)
+    const resolvedDir = dir ? path.resolve(dir) : resolvedHome;
+    const isHomeDirectory = resolvedDir === resolvedHome;
+
+    if (isHomeDirectory) {
+      // For home directory, only check for QWEN.md directly in the home directory
+      const homeContextPath = path.join(resolvedHome, geminiMdFilename);
+      try {
+        await fs.access(homeContextPath, fsSync.constants.R_OK);
+        if (homeContextPath !== globalMemoryPath) {
+          allPaths.add(homeContextPath);
+          if (debugMode)
+            logger.debug(
+              `Found readable home ${geminiMdFilename}: ${homeContextPath}`,
+            );
+        }
+      } catch {
+        // Not found, which is okay
+      }
+    } else if (dir) {
+      // FIX: Only perform the workspace search (upward and downward scans)
+      // if a valid currentWorkingDirectory is provided and it's not the home directory.
+      const resolvedCwd = path.resolve(dir);
+      if (debugMode)
+        logger.debug(
+          `Searching for ${geminiMdFilename} starting from CWD: ${resolvedCwd}`,
+        );
+
+      const projectRoot = await findProjectRoot(resolvedCwd);
+      if (debugMode)
+        logger.debug(`Determined project root: ${projectRoot ?? 'None'}`);
+
+      const upwardPaths: string[] = [];
+      let currentDir = resolvedCwd;
+      const ultimateStopDir = projectRoot
+        ? path.dirname(projectRoot)
+        : path.dirname(resolvedHome);
+
+      while (currentDir && currentDir !== path.dirname(currentDir)) {
+        if (currentDir === path.join(resolvedHome, GEMINI_CONFIG_DIR)) {
+          break;
+        }
+
+        const potentialPath = path.join(currentDir, geminiMdFilename);
+        try {
+          await fs.access(potentialPath, fsSync.constants.R_OK);
+          if (potentialPath !== globalMemoryPath) {
+            upwardPaths.unshift(potentialPath);
+          }
+        } catch {
+          // Not found, continue.
+        }
+
+        if (currentDir === ultimateStopDir) {
+          break;
+        }
+
+        currentDir = path.dirname(currentDir);
+      }
+      upwardPaths.forEach((p) => allPaths.add(p));
+
+      const mergedOptions = {
+        ...DEFAULT_MEMORY_FILE_FILTERING_OPTIONS,
+        ...fileFilteringOptions,
+      };
+
+      const downwardPaths = await bfsFileSearch(resolvedCwd, {
+        fileName: geminiMdFilename,
+        maxDirs,
+        debug: debugMode,
+        fileService,
+        fileFilteringOptions: mergedOptions,
+      });
+      downwardPaths.sort();
+      for (const dPath of downwardPaths) {
+        allPaths.add(dPath);
+      }
+    }
+  }
+
+  // Add extension context file paths.
+  for (const extensionPath of extensionContextFilePaths) {
+    allPaths.add(extensionPath);
+  }
+
+  const finalPaths = Array.from(allPaths);
+
+  if (debugMode)
+    logger.debug(
+      `Final ordered ${getAllGeminiMdFilenames()} paths to read: ${JSON.stringify(
+        finalPaths,
+      )}`,
+    );
+  return finalPaths;
+}
+
+async function readGeminiMdFiles(
+  filePaths: string[],
+  debugMode: boolean,
+  importFormat: 'flat' | 'tree' = 'tree',
+): Promise<GeminiFileContent[]> {
+  const results: GeminiFileContent[] = [];
+  for (const filePath of filePaths) {
+    try {
+      const content = await fs.readFile(filePath, 'utf-8');
+
+      // Process imports in the content
+      const processedResult = await processImports(
+        content,
+        path.dirname(filePath),
+        debugMode,
+        undefined,
+        undefined,
+        importFormat,
+      );
+
+      results.push({ filePath, content: processedResult.content });
+      if (debugMode)
+        logger.debug(
+          `Successfully read and processed imports: ${filePath} (Length: ${processedResult.content.length})`,
+        );
+    } catch (error: unknown) {
+      const isTestEnv =
+        process.env['NODE_ENV'] === 'test' || process.env['VITEST'];
+      if (!isTestEnv) {
+        const message = error instanceof Error ? error.message : String(error);
+        logger.warn(
+          `Warning: Could not read ${getAllGeminiMdFilenames()} file at ${filePath}. Error: ${message}`,
+        );
+      }
+      results.push({ filePath, content: null }); // Still include it with null content
+      if (debugMode) logger.debug(`Failed to read: ${filePath}`);
+    }
+  }
+  return results;
+}
+
+function concatenateInstructions(
+  instructionContents: GeminiFileContent[],
+  // CWD is needed to resolve relative paths for display markers
+  currentWorkingDirectoryForDisplay: string,
+): string {
+  return instructionContents
+    .filter((item) => typeof item.content === 'string')
+    .map((item) => {
+      const trimmedContent = (item.content as string).trim();
+      if (trimmedContent.length === 0) {
+        return null;
+      }
+      const displayPath = path.isAbsolute(item.filePath)
+        ? path.relative(currentWorkingDirectoryForDisplay, item.filePath)
+        : item.filePath;
+      return `--- Context from: ${displayPath} ---\n${trimmedContent}\n--- End of Context from: ${displayPath} ---`;
+    })
+    .filter((block): block is string => block !== null)
+    .join('\n\n');
+}
+
+/**
+ * Loads hierarchical QWEN.md files and concatenates their content.
+ * This function is intended for use by the server.
+ */
+export async function loadServerHierarchicalMemory(
+  currentWorkingDirectory: string,
+  includeDirectoriesToReadGemini: readonly string[],
+  debugMode: boolean,
+  fileService: FileDiscoveryService,
+  extensionContextFilePaths: string[] = [],
+  importFormat: 'flat' | 'tree' = 'tree',
+  fileFilteringOptions?: FileFilteringOptions,
+  maxDirs: number = 200,
+): Promise<{ memoryContent: string; fileCount: number }> {
+  if (debugMode)
+    logger.debug(
+      `Loading server hierarchical memory for CWD: ${currentWorkingDirectory} (importFormat: ${importFormat})`,
+    );
+
+  // For the server, homedir() refers to the server process's home.
+  // This is consistent with how MemoryTool already finds the global path.
+  const userHomePath = homedir();
+  const filePaths = await getGeminiMdFilePathsInternal(
+    currentWorkingDirectory,
+    includeDirectoriesToReadGemini,
+    userHomePath,
+    debugMode,
+    fileService,
+    extensionContextFilePaths,
+    fileFilteringOptions || DEFAULT_MEMORY_FILE_FILTERING_OPTIONS,
+    maxDirs,
+  );
+  if (filePaths.length === 0) {
+    if (debugMode) logger.debug('No QWEN.md files found in hierarchy.');
+    return { memoryContent: '', fileCount: 0 };
+  }
+  const contentsWithPaths = await readGeminiMdFiles(
+    filePaths,
+    debugMode,
+    importFormat,
+  );
+  // Pass CWD for relative path display in concatenated content
+  const combinedInstructions = concatenateInstructions(
+    contentsWithPaths,
+    currentWorkingDirectory,
+  );
+  if (debugMode)
+    logger.debug(
+      `Combined instructions length: ${combinedInstructions.length}`,
+    );
+  if (debugMode && combinedInstructions.length > 0)
+    logger.debug(
+      `Combined instructions (snippet): ${combinedInstructions.substring(0, 500)}...`,
+    );
+  return {
+    memoryContent: combinedInstructions,
+    fileCount: contentsWithPaths.length,
+  };
+}

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

@@ -0,0 +1,1048 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { marked } from 'marked';
+import { processImports, validateImportPath } from './memoryImportProcessor.js';
+
+// Helper function to create platform-agnostic test paths
+function testPath(...segments: string[]): string {
+  // Start with the first segment as is (might be an absolute path on Windows)
+  let result = segments[0];
+
+  // Join remaining segments with the platform-specific separator
+  for (let i = 1; i < segments.length; i++) {
+    if (segments[i].startsWith('/') || segments[i].startsWith('\\')) {
+      // If segment starts with a separator, remove the trailing separator from the result
+      result = path.normalize(result.replace(/[\\/]+$/, '') + segments[i]);
+    } else {
+      // Otherwise join with the platform separator
+      result = path.join(result, segments[i]);
+    }
+  }
+
+  return path.normalize(result);
+}
+
+vi.mock('fs/promises');
+const mockedFs = vi.mocked(fs);
+
+// Mock console methods to capture warnings
+const originalConsoleWarn = console.warn;
+const originalConsoleError = console.error;
+const originalConsoleDebug = console.debug;
+
+// Helper functions using marked for parsing and validation
+const parseMarkdown = (content: string) => marked.lexer(content);
+
+const findMarkdownComments = (content: string): string[] => {
+  const tokens = parseMarkdown(content);
+  const comments: string[] = [];
+
+  function walkTokens(tokenList: unknown[]) {
+    for (const token of tokenList) {
+      const t = token as { type: string; raw: string; tokens?: unknown[] };
+      if (t.type === 'html' && t.raw.includes('<!--')) {
+        comments.push(t.raw.trim());
+      }
+      if (t.tokens) {
+        walkTokens(t.tokens);
+      }
+    }
+  }
+
+  walkTokens(tokens);
+  return comments;
+};
+
+const findCodeBlocks = (
+  content: string,
+): Array<{ type: string; content: string }> => {
+  const tokens = parseMarkdown(content);
+  const codeBlocks: Array<{ type: string; content: string }> = [];
+
+  function walkTokens(tokenList: unknown[]) {
+    for (const token of tokenList) {
+      const t = token as { type: string; text: string; tokens?: unknown[] };
+      if (t.type === 'code') {
+        codeBlocks.push({
+          type: 'code_block',
+          content: t.text,
+        });
+      } else if (t.type === 'codespan') {
+        codeBlocks.push({
+          type: 'inline_code',
+          content: t.text,
+        });
+      }
+      if (t.tokens) {
+        walkTokens(t.tokens);
+      }
+    }
+  }
+
+  walkTokens(tokens);
+  return codeBlocks;
+};
+
+describe('memoryImportProcessor', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    // Mock console methods
+    console.warn = vi.fn();
+    console.error = vi.fn();
+    console.debug = vi.fn();
+  });
+
+  afterEach(() => {
+    // Restore console methods
+    console.warn = originalConsoleWarn;
+    console.error = originalConsoleError;
+    console.debug = originalConsoleDebug;
+  });
+
+  describe('processImports', () => {
+    it('should process basic md file imports', async () => {
+      const content = 'Some content @./test.md more content';
+      const basePath = testPath('test', 'path');
+      const importedContent = '# Imported Content\nThis is imported.';
+
+      mockedFs.access.mockResolvedValue(undefined);
+      mockedFs.readFile.mockResolvedValue(importedContent);
+
+      const result = await processImports(content, basePath, true);
+
+      // Use marked to find HTML comments (import markers)
+      const comments = findMarkdownComments(result.content);
+      expect(comments.some((c) => c.includes('Imported from: ./test.md'))).toBe(
+        true,
+      );
+      expect(
+        comments.some((c) => c.includes('End of import from: ./test.md')),
+      ).toBe(true);
+
+      // Verify the imported content is present
+      expect(result.content).toContain(importedContent);
+
+      // Verify the markdown structure is valid
+      const tokens = parseMarkdown(result.content);
+      expect(tokens).toBeDefined();
+      expect(tokens.length).toBeGreaterThan(0);
+
+      expect(mockedFs.readFile).toHaveBeenCalledWith(
+        path.resolve(basePath, './test.md'),
+        'utf-8',
+      );
+    });
+
+    it('should import non-md files just like md files', async () => {
+      const content = 'Some content @./instructions.txt more content';
+      const basePath = testPath('test', 'path');
+      const importedContent =
+        '# Instructions\nThis is a text file with markdown.';
+
+      mockedFs.access.mockResolvedValue(undefined);
+      mockedFs.readFile.mockResolvedValue(importedContent);
+
+      const result = await processImports(content, basePath, true);
+
+      // Use marked to find import comments
+      const comments = findMarkdownComments(result.content);
+      expect(
+        comments.some((c) => c.includes('Imported from: ./instructions.txt')),
+      ).toBe(true);
+      expect(
+        comments.some((c) =>
+          c.includes('End of import from: ./instructions.txt'),
+        ),
+      ).toBe(true);
+
+      // Use marked to parse and validate the imported content structure
+      const tokens = parseMarkdown(result.content);
+
+      // Find headers in the parsed content
+      const headers = tokens.filter((token) => token.type === 'heading');
+      expect(
+        headers.some((h) => (h as { text: string }).text === 'Instructions'),
+      ).toBe(true);
+
+      // Verify the imported content is present
+      expect(result.content).toContain(importedContent);
+      expect(console.warn).not.toHaveBeenCalled();
+      expect(mockedFs.readFile).toHaveBeenCalledWith(
+        path.resolve(basePath, './instructions.txt'),
+        'utf-8',
+      );
+    });
+
+    it('should handle circular imports', async () => {
+      const content = 'Content @./circular.md more content';
+      const basePath = testPath('test', 'path');
+      const circularContent = 'Circular @./main.md content';
+
+      mockedFs.access.mockResolvedValue(undefined);
+      mockedFs.readFile.mockResolvedValue(circularContent);
+
+      // Set up the import state to simulate we're already processing main.md
+      const importState = {
+        processedFiles: new Set<string>(),
+        maxDepth: 10,
+        currentDepth: 0,
+        currentFile: testPath('test', 'path', 'main.md'), // Simulate we're processing main.md
+      };
+
+      const result = await processImports(content, basePath, true, importState);
+
+      // The circular import should be detected when processing the nested import
+      expect(result.content).toContain(
+        '<!-- File already processed: ./main.md -->',
+      );
+    });
+
+    it('should handle file not found errors', async () => {
+      const content = 'Content @./nonexistent.md more content';
+      const basePath = testPath('test', 'path');
+
+      mockedFs.access.mockRejectedValue(new Error('File not found'));
+
+      const result = await processImports(content, basePath, true);
+
+      expect(result.content).toContain(
+        '<!-- Import failed: ./nonexistent.md - File not found -->',
+      );
+      expect(console.error).toHaveBeenCalledWith(
+        '[ERROR] [ImportProcessor]',
+        'Failed to import ./nonexistent.md: File not found',
+      );
+    });
+
+    it('should respect max depth limit', async () => {
+      const content = 'Content @./deep.md more content';
+      const basePath = testPath('test', 'path');
+      const deepContent = 'Deep @./deeper.md content';
+
+      mockedFs.access.mockResolvedValue(undefined);
+      mockedFs.readFile.mockResolvedValue(deepContent);
+
+      const importState = {
+        processedFiles: new Set<string>(),
+        maxDepth: 1,
+        currentDepth: 1,
+      };
+
+      const result = await processImports(content, basePath, true, importState);
+
+      expect(console.warn).toHaveBeenCalledWith(
+        '[WARN] [ImportProcessor]',
+        'Maximum import depth (1) reached. Stopping import processing.',
+      );
+      expect(result.content).toBe(content);
+    });
+
+    it('should handle nested imports recursively', async () => {
+      const content = 'Main @./nested.md content';
+      const basePath = testPath('test', 'path');
+      const nestedContent = 'Nested @./inner.md content';
+      const innerContent = 'Inner content';
+
+      mockedFs.access.mockResolvedValue(undefined);
+      mockedFs.readFile
+        .mockResolvedValueOnce(nestedContent)
+        .mockResolvedValueOnce(innerContent);
+
+      const result = await processImports(content, basePath, true);
+
+      expect(result.content).toContain('<!-- Imported from: ./nested.md -->');
+      expect(result.content).toContain('<!-- Imported from: ./inner.md -->');
+      expect(result.content).toContain(innerContent);
+    });
+
+    it('should handle absolute paths in imports', async () => {
+      const content = 'Content @/absolute/path/file.md more content';
+      const basePath = testPath('test', 'path');
+      const importedContent = 'Absolute path content';
+
+      mockedFs.access.mockResolvedValue(undefined);
+      mockedFs.readFile.mockResolvedValue(importedContent);
+
+      const result = await processImports(content, basePath, true);
+
+      expect(result.content).toContain(
+        '<!-- Import failed: /absolute/path/file.md - Path traversal attempt -->',
+      );
+    });
+
+    it('should handle multiple imports in same content', async () => {
+      const content = 'Start @./first.md middle @./second.md end';
+      const basePath = testPath('test', 'path');
+      const firstContent = 'First content';
+      const secondContent = 'Second content';
+
+      mockedFs.access.mockResolvedValue(undefined);
+      mockedFs.readFile
+        .mockResolvedValueOnce(firstContent)
+        .mockResolvedValueOnce(secondContent);
+
+      const result = await processImports(content, basePath, true);
+
+      expect(result.content).toContain('<!-- Imported from: ./first.md -->');
+      expect(result.content).toContain('<!-- Imported from: ./second.md -->');
+      expect(result.content).toContain(firstContent);
+      expect(result.content).toContain(secondContent);
+    });
+
+    it('should ignore imports inside code blocks', async () => {
+      const content = [
+        'Normal content @./should-import.md',
+        '```',
+        'code block with @./should-not-import.md',
+        '```',
+        'More content @./should-import2.md',
+      ].join('\n');
+      const projectRoot = testPath('test', 'project');
+      const basePath = testPath(projectRoot, 'src');
+      const importedContent1 = 'Imported 1';
+      const importedContent2 = 'Imported 2';
+      // Only the imports outside code blocks should be processed
+      mockedFs.access.mockResolvedValue(undefined);
+      mockedFs.readFile
+        .mockResolvedValueOnce(importedContent1)
+        .mockResolvedValueOnce(importedContent2);
+      const result = await processImports(
+        content,
+        basePath,
+        true,
+        undefined,
+        projectRoot,
+      );
+
+      // Use marked to verify imported content is present
+      expect(result.content).toContain(importedContent1);
+      expect(result.content).toContain(importedContent2);
+
+      // Use marked to find code blocks and verify the import wasn't processed
+      const codeBlocks = findCodeBlocks(result.content);
+      const hasUnprocessedImport = codeBlocks.some((block) =>
+        block.content.includes('@./should-not-import.md'),
+      );
+      expect(hasUnprocessedImport).toBe(true);
+
+      // Verify no import comment was created for the code block import
+      const comments = findMarkdownComments(result.content);
+      expect(comments.some((c) => c.includes('should-not-import.md'))).toBe(
+        false,
+      );
+    });
+
+    it('should ignore imports inside inline code', async () => {
+      const content = [
+        'Normal content @./should-import.md',
+        '`code with import @./should-not-import.md`',
+        'More content @./should-import2.md',
+      ].join('\n');
+      const projectRoot = testPath('test', 'project');
+      const basePath = testPath(projectRoot, 'src');
+      const importedContent1 = 'Imported 1';
+      const importedContent2 = 'Imported 2';
+      mockedFs.access.mockResolvedValue(undefined);
+      mockedFs.readFile
+        .mockResolvedValueOnce(importedContent1)
+        .mockResolvedValueOnce(importedContent2);
+      const result = await processImports(
+        content,
+        basePath,
+        true,
+        undefined,
+        projectRoot,
+      );
+
+      // Verify imported content is present
+      expect(result.content).toContain(importedContent1);
+      expect(result.content).toContain(importedContent2);
+
+      // Use marked to find inline code spans
+      const codeBlocks = findCodeBlocks(result.content);
+      const inlineCodeSpans = codeBlocks.filter(
+        (block) => block.type === 'inline_code',
+      );
+
+      // Verify the inline code span still contains the unprocessed import
+      expect(
+        inlineCodeSpans.some((span) =>
+          span.content.includes('@./should-not-import.md'),
+        ),
+      ).toBe(true);
+
+      // Verify no import comments were created for inline code imports
+      const comments = findMarkdownComments(result.content);
+      expect(comments.some((c) => c.includes('should-not-import.md'))).toBe(
+        false,
+      );
+    });
+
+    it('should handle nested tokens and non-unique content correctly', async () => {
+      // This test verifies the robust findCodeRegions implementation
+      // that recursively walks the token tree and handles non-unique content
+      const content = [
+        'Normal content @./should-import.md',
+        'Paragraph with `inline code @./should-not-import.md` and more text.',
+        'Another paragraph with the same `inline code @./should-not-import.md` text.',
+        'More content @./should-import2.md',
+      ].join('\n');
+      const projectRoot = testPath('test', 'project');
+      const basePath = testPath(projectRoot, 'src');
+      const importedContent1 = 'Imported 1';
+      const importedContent2 = 'Imported 2';
+      mockedFs.access.mockResolvedValue(undefined);
+      mockedFs.readFile
+        .mockResolvedValueOnce(importedContent1)
+        .mockResolvedValueOnce(importedContent2);
+      const result = await processImports(
+        content,
+        basePath,
+        true,
+        undefined,
+        projectRoot,
+      );
+
+      // Should process imports outside code regions
+      expect(result.content).toContain(importedContent1);
+      expect(result.content).toContain(importedContent2);
+
+      // Should preserve imports inside inline code (both occurrences)
+      expect(result.content).toContain('`inline code @./should-not-import.md`');
+
+      // Should not have processed the imports inside code regions
+      expect(result.content).not.toContain(
+        '<!-- Imported from: ./should-not-import.md -->',
+      );
+    });
+
+    it('should allow imports from parent and subdirectories within project root', async () => {
+      const content =
+        'Parent import: @../parent.md Subdir import: @./components/sub.md';
+      const projectRoot = testPath('test', 'project');
+      const basePath = testPath(projectRoot, 'src');
+      const importedParent = 'Parent file content';
+      const importedSub = 'Subdir file content';
+      mockedFs.access.mockResolvedValue(undefined);
+      mockedFs.readFile
+        .mockResolvedValueOnce(importedParent)
+        .mockResolvedValueOnce(importedSub);
+      const result = await processImports(
+        content,
+        basePath,
+        true,
+        undefined,
+        projectRoot,
+      );
+      expect(result.content).toContain(importedParent);
+      expect(result.content).toContain(importedSub);
+    });
+
+    it('should reject imports outside project root', async () => {
+      const content = 'Outside import: @../../../etc/passwd';
+      const projectRoot = testPath('test', 'project');
+      const basePath = testPath(projectRoot, 'src');
+      const result = await processImports(
+        content,
+        basePath,
+        true,
+        undefined,
+        projectRoot,
+      );
+      expect(result.content).toContain(
+        '<!-- Import failed: ../../../etc/passwd - Path traversal attempt -->',
+      );
+    });
+
+    it('should build import tree structure', async () => {
+      const content = 'Main content @./nested.md @./simple.md';
+      const projectRoot = testPath('test', 'project');
+      const basePath = testPath(projectRoot, 'src');
+      const nestedContent = 'Nested @./inner.md content';
+      const simpleContent = 'Simple content';
+      const innerContent = 'Inner content';
+
+      mockedFs.access.mockResolvedValue(undefined);
+      mockedFs.readFile
+        .mockResolvedValueOnce(nestedContent)
+        .mockResolvedValueOnce(simpleContent)
+        .mockResolvedValueOnce(innerContent);
+
+      const result = await processImports(content, basePath, true);
+
+      // Use marked to find and validate import comments
+      const comments = findMarkdownComments(result.content);
+      const importComments = comments.filter((c) =>
+        c.includes('Imported from:'),
+      );
+
+      expect(importComments.some((c) => c.includes('./nested.md'))).toBe(true);
+      expect(importComments.some((c) => c.includes('./simple.md'))).toBe(true);
+      expect(importComments.some((c) => c.includes('./inner.md'))).toBe(true);
+
+      // Use marked to validate the markdown structure is well-formed
+      const tokens = parseMarkdown(result.content);
+      expect(tokens).toBeDefined();
+      expect(tokens.length).toBeGreaterThan(0);
+
+      // Verify the content contains expected text using marked parsing
+      const textContent = tokens
+        .filter((token) => token.type === 'paragraph')
+        .map((token) => token.raw)
+        .join(' ');
+
+      expect(textContent).toContain('Main content');
+      expect(textContent).toContain('Nested');
+      expect(textContent).toContain('Simple content');
+      expect(textContent).toContain('Inner content');
+
+      // Verify import tree structure
+      expect(result.importTree.path).toBe('unknown'); // No currentFile set in test
+      expect(result.importTree.imports).toHaveLength(2);
+
+      // First import: nested.md
+      // Check that the paths match using includes to handle potential absolute/relative differences
+      const expectedNestedPath = testPath(projectRoot, 'src', 'nested.md');
+
+      expect(result.importTree.imports![0].path).toContain(expectedNestedPath);
+      expect(result.importTree.imports![0].imports).toHaveLength(1);
+
+      const expectedInnerPath = testPath(projectRoot, 'src', 'inner.md');
+      expect(result.importTree.imports![0].imports![0].path).toContain(
+        expectedInnerPath,
+      );
+      expect(result.importTree.imports![0].imports![0].imports).toBeUndefined();
+
+      // Second import: simple.md
+      const expectedSimplePath = testPath(projectRoot, 'src', 'simple.md');
+      expect(result.importTree.imports![1].path).toContain(expectedSimplePath);
+      expect(result.importTree.imports![1].imports).toBeUndefined();
+    });
+
+    it('should produce flat output in Claude-style with unique files in order', async () => {
+      const content = 'Main @./nested.md content @./simple.md';
+      const projectRoot = testPath('test', 'project');
+      const basePath = testPath(projectRoot, 'src');
+      const nestedContent = 'Nested @./inner.md content';
+      const simpleContent = 'Simple content';
+      const innerContent = 'Inner content';
+
+      mockedFs.access.mockResolvedValue(undefined);
+      mockedFs.readFile
+        .mockResolvedValueOnce(nestedContent)
+        .mockResolvedValueOnce(simpleContent)
+        .mockResolvedValueOnce(innerContent);
+
+      const result = await processImports(
+        content,
+        basePath,
+        true,
+        undefined,
+        projectRoot,
+        'flat',
+      );
+
+      // Use marked to parse the output and validate structure
+      const tokens = parseMarkdown(result.content);
+      expect(tokens).toBeDefined();
+
+      // Find all file markers using marked parsing
+      const fileMarkers: string[] = [];
+      const endMarkers: string[] = [];
+
+      function walkTokens(tokenList: unknown[]) {
+        for (const token of tokenList) {
+          const t = token as { type: string; raw: string; tokens?: unknown[] };
+          if (t.type === 'paragraph' && t.raw.includes('--- File:')) {
+            const match = t.raw.match(/--- File: (.+?) ---/);
+            if (match) {
+              // Normalize the path before adding to fileMarkers
+              fileMarkers.push(path.normalize(match[1]));
+            }
+          }
+          if (t.type === 'paragraph' && t.raw.includes('--- End of File:')) {
+            const match = t.raw.match(/--- End of File: (.+?) ---/);
+            if (match) {
+              // Normalize the path before adding to endMarkers
+              endMarkers.push(path.normalize(match[1]));
+            }
+          }
+          if (t.tokens) {
+            walkTokens(t.tokens);
+          }
+        }
+      }
+
+      walkTokens(tokens);
+
+      // Verify all expected files are present
+      const expectedFiles = ['nested.md', 'simple.md', 'inner.md'];
+
+      // Check that each expected file is present in the content
+      expectedFiles.forEach((file) => {
+        expect(result.content).toContain(file);
+      });
+
+      // Verify content is present
+      expect(result.content).toContain(
+        'Main @./nested.md content @./simple.md',
+      );
+      expect(result.content).toContain('Nested @./inner.md content');
+      expect(result.content).toContain('Simple content');
+      expect(result.content).toContain('Inner content');
+
+      // Verify end markers exist
+      expect(endMarkers.length).toBeGreaterThan(0);
+    });
+
+    it('should not duplicate files in flat output if imported multiple times', async () => {
+      const content = 'Main @./dup.md again @./dup.md';
+      const projectRoot = testPath('test', 'project');
+      const basePath = testPath(projectRoot, 'src');
+      const dupContent = 'Duplicated content';
+
+      // Reset mocks
+      mockedFs.access.mockReset();
+      mockedFs.readFile.mockReset();
+
+      // Set up mocks
+      mockedFs.access.mockResolvedValue(undefined);
+      mockedFs.readFile.mockResolvedValue(dupContent);
+
+      const result = await processImports(
+        content,
+        basePath,
+        true, // followImports
+        undefined, // allowedPaths
+        projectRoot,
+        'flat', // outputFormat
+      );
+
+      // Verify readFile was called only once for dup.md
+      expect(mockedFs.readFile).toHaveBeenCalledTimes(1);
+
+      // Check that the content contains the file content only once
+      const contentStr = result.content;
+      const firstIndex = contentStr.indexOf('Duplicated content');
+      const lastIndex = contentStr.lastIndexOf('Duplicated content');
+      expect(firstIndex).toBeGreaterThan(-1); // Content should exist
+      expect(firstIndex).toBe(lastIndex); // Should only appear once
+    });
+
+    it('should handle nested imports in flat output', async () => {
+      const content = 'Root @./a.md';
+      const projectRoot = testPath('test', 'project');
+      const basePath = testPath(projectRoot, 'src');
+      const aContent = 'A @./b.md';
+      const bContent = 'B content';
+
+      mockedFs.access.mockResolvedValue(undefined);
+      mockedFs.readFile
+        .mockResolvedValueOnce(aContent)
+        .mockResolvedValueOnce(bContent);
+
+      const result = await processImports(
+        content,
+        basePath,
+        true,
+        undefined,
+        projectRoot,
+        'flat',
+      );
+
+      // Verify all files are present by checking for their basenames
+      expect(result.content).toContain('a.md');
+      expect(result.content).toContain('b.md');
+
+      // Verify content is in the correct order
+      const contentStr = result.content;
+      const aIndex = contentStr.indexOf('a.md');
+      const bIndex = contentStr.indexOf('b.md');
+      const rootIndex = contentStr.indexOf('Root @./a.md');
+
+      expect(rootIndex).toBeLessThan(aIndex);
+      expect(aIndex).toBeLessThan(bIndex);
+
+      // Verify content is present
+      expect(result.content).toContain('Root @./a.md');
+      expect(result.content).toContain('A @./b.md');
+      expect(result.content).toContain('B content');
+    });
+
+    it('should build import tree structure', async () => {
+      const content = 'Main content @./nested.md @./simple.md';
+      const projectRoot = testPath('test', 'project');
+      const basePath = testPath(projectRoot, 'src');
+      const nestedContent = 'Nested @./inner.md content';
+      const simpleContent = 'Simple content';
+      const innerContent = 'Inner content';
+
+      mockedFs.access.mockResolvedValue(undefined);
+      mockedFs.readFile
+        .mockResolvedValueOnce(nestedContent)
+        .mockResolvedValueOnce(simpleContent)
+        .mockResolvedValueOnce(innerContent);
+
+      const result = await processImports(content, basePath, true);
+
+      // Use marked to find and validate import comments
+      const comments = findMarkdownComments(result.content);
+      const importComments = comments.filter((c) =>
+        c.includes('Imported from:'),
+      );
+
+      expect(importComments.some((c) => c.includes('./nested.md'))).toBe(true);
+      expect(importComments.some((c) => c.includes('./simple.md'))).toBe(true);
+      expect(importComments.some((c) => c.includes('./inner.md'))).toBe(true);
+
+      // Use marked to validate the markdown structure is well-formed
+      const tokens = parseMarkdown(result.content);
+      expect(tokens).toBeDefined();
+      expect(tokens.length).toBeGreaterThan(0);
+
+      // Verify the content contains expected text using marked parsing
+      const textContent = tokens
+        .filter((token) => token.type === 'paragraph')
+        .map((token) => token.raw)
+        .join(' ');
+
+      expect(textContent).toContain('Main content');
+      expect(textContent).toContain('Nested');
+      expect(textContent).toContain('Simple content');
+      expect(textContent).toContain('Inner content');
+
+      // Verify import tree structure
+      expect(result.importTree.path).toBe('unknown'); // No currentFile set in test
+      expect(result.importTree.imports).toHaveLength(2);
+
+      // First import: nested.md
+      const expectedNestedPath = testPath(projectRoot, 'src', 'nested.md');
+      const expectedInnerPath = testPath(projectRoot, 'src', 'inner.md');
+      const expectedSimplePath = testPath(projectRoot, 'src', 'simple.md');
+
+      // Check that the paths match using includes to handle potential absolute/relative differences
+      expect(result.importTree.imports![0].path).toContain(expectedNestedPath);
+      expect(result.importTree.imports![0].imports).toHaveLength(1);
+      expect(result.importTree.imports![0].imports![0].path).toContain(
+        expectedInnerPath,
+      );
+      expect(result.importTree.imports![0].imports![0].imports).toBeUndefined();
+
+      // Second import: simple.md
+      expect(result.importTree.imports![1].path).toContain(expectedSimplePath);
+      expect(result.importTree.imports![1].imports).toBeUndefined();
+    });
+
+    it('should produce flat output in Claude-style with unique files in order', async () => {
+      const content = 'Main @./nested.md content @./simple.md';
+      const projectRoot = testPath('test', 'project');
+      const basePath = testPath(projectRoot, 'src');
+      const nestedContent = 'Nested @./inner.md content';
+      const simpleContent = 'Simple content';
+      const innerContent = 'Inner content';
+
+      mockedFs.access.mockResolvedValue(undefined);
+      mockedFs.readFile
+        .mockResolvedValueOnce(nestedContent)
+        .mockResolvedValueOnce(simpleContent)
+        .mockResolvedValueOnce(innerContent);
+
+      const result = await processImports(
+        content,
+        basePath,
+        true,
+        undefined,
+        projectRoot,
+        'flat',
+      );
+
+      // Verify all expected files are present by checking for their basenames
+      expect(result.content).toContain('nested.md');
+      expect(result.content).toContain('simple.md');
+      expect(result.content).toContain('inner.md');
+
+      // Verify content is present
+      expect(result.content).toContain('Nested @./inner.md content');
+      expect(result.content).toContain('Simple content');
+      expect(result.content).toContain('Inner content');
+    });
+
+    it('should not duplicate files in flat output if imported multiple times', async () => {
+      const content = 'Main @./dup.md again @./dup.md';
+      const projectRoot = testPath('test', 'project');
+      const basePath = testPath(projectRoot, 'src');
+      const dupContent = 'Duplicated content';
+
+      // Create a normalized path for the duplicate file
+      const dupFilePath = path.normalize(path.join(basePath, 'dup.md'));
+
+      // Mock the file system access
+      mockedFs.access.mockImplementation((filePath) => {
+        const pathStr = filePath.toString();
+        if (path.normalize(pathStr) === dupFilePath) {
+          return Promise.resolve();
+        }
+        return Promise.reject(new Error(`File not found: ${pathStr}`));
+      });
+
+      // Mock the file reading
+      mockedFs.readFile.mockImplementation((filePath) => {
+        const pathStr = filePath.toString();
+        if (path.normalize(pathStr) === dupFilePath) {
+          return Promise.resolve(dupContent);
+        }
+        return Promise.reject(new Error(`File not found: ${pathStr}`));
+      });
+
+      const result = await processImports(
+        content,
+        basePath,
+        true, // debugMode
+        undefined, // importState
+        projectRoot,
+        'flat',
+      );
+
+      // In flat mode, the output should only contain the main file content with import markers
+      // The imported file content should not be included in the flat output
+      expect(result.content).toContain('Main @./dup.md again @./dup.md');
+
+      // The imported file content should not appear in the output
+      // This is the current behavior of the implementation
+      expect(result.content).not.toContain(dupContent);
+
+      // The file marker should not appear in the output
+      // since the imported file content is not included in flat mode
+      const fileMarker = `--- File: ${dupFilePath} ---`;
+      expect(result.content).not.toContain(fileMarker);
+      expect(result.content).not.toContain('--- End of File: ' + dupFilePath);
+
+      // The main file path should be in the output
+      // Since we didn't pass an importState, it will use the basePath as the file path
+      const mainFilePath = path.normalize(path.resolve(basePath));
+      expect(result.content).toContain(`--- File: ${mainFilePath} ---`);
+      expect(result.content).toContain(`--- End of File: ${mainFilePath}`);
+    });
+
+    it('should handle nested imports in flat output', async () => {
+      const content = 'Root @./a.md';
+      const projectRoot = testPath('test', 'project');
+      const basePath = testPath(projectRoot, 'src');
+      const aContent = 'A @./b.md';
+      const bContent = 'B content';
+
+      mockedFs.access.mockResolvedValue(undefined);
+      mockedFs.readFile
+        .mockResolvedValueOnce(aContent)
+        .mockResolvedValueOnce(bContent);
+
+      const result = await processImports(
+        content,
+        basePath,
+        true,
+        undefined,
+        projectRoot,
+        'flat',
+      );
+
+      // Verify all files are present by checking for their basenames
+      expect(result.content).toContain('a.md');
+      expect(result.content).toContain('b.md');
+
+      // Verify content is in the correct order
+      const contentStr = result.content;
+      const aIndex = contentStr.indexOf('a.md');
+      const bIndex = contentStr.indexOf('b.md');
+      const rootIndex = contentStr.indexOf('Root @./a.md');
+
+      expect(rootIndex).toBeLessThan(aIndex);
+      expect(aIndex).toBeLessThan(bIndex);
+
+      // Verify content is present
+      expect(result.content).toContain('Root @./a.md');
+      expect(result.content).toContain('A @./b.md');
+      expect(result.content).toContain('B content');
+    });
+  });
+
+  describe('validateImportPath', () => {
+    it('should reject URLs', () => {
+      const basePath = testPath('base');
+      const allowedPath = testPath('allowed');
+      expect(
+        validateImportPath('https://example.com/file.md', basePath, [
+          allowedPath,
+        ]),
+      ).toBe(false);
+      expect(
+        validateImportPath('http://example.com/file.md', basePath, [
+          allowedPath,
+        ]),
+      ).toBe(false);
+      expect(
+        validateImportPath('file:///path/to/file.md', basePath, [allowedPath]),
+      ).toBe(false);
+    });
+
+    it('should allow paths within allowed directories', () => {
+      const basePath = path.resolve(testPath('base'));
+      const allowedPath = path.resolve(testPath('allowed'));
+
+      // Test relative paths - resolve them against basePath
+      const relativePath = './file.md';
+      path.resolve(basePath, relativePath);
+      expect(validateImportPath(relativePath, basePath, [basePath])).toBe(true);
+
+      // Test parent directory access (should be allowed if parent is in allowed paths)
+      const parentPath = path.dirname(basePath);
+      if (parentPath !== basePath) {
+        // Only test if parent is different
+        const parentRelativePath = '../file.md';
+        path.resolve(basePath, parentRelativePath);
+        expect(
+          validateImportPath(parentRelativePath, basePath, [parentPath]),
+        ).toBe(true);
+
+        path.resolve(basePath, 'sub');
+        const resultSub = validateImportPath('sub', basePath, [basePath]);
+        expect(resultSub).toBe(true);
+      }
+
+      // Test allowed path access - use a file within the allowed directory
+      const allowedSubPath = 'nested';
+      const allowedFilePath = path.join(allowedPath, allowedSubPath, 'file.md');
+      expect(validateImportPath(allowedFilePath, basePath, [allowedPath])).toBe(
+        true,
+      );
+    });
+
+    it('should reject paths outside allowed directories', () => {
+      const basePath = path.resolve(testPath('base'));
+      const allowedPath = path.resolve(testPath('allowed'));
+      const forbiddenPath = path.resolve(testPath('forbidden'));
+
+      // Forbidden path should be blocked
+      expect(validateImportPath(forbiddenPath, basePath, [allowedPath])).toBe(
+        false,
+      );
+
+      // Relative path to forbidden directory should be blocked
+      const relativeToForbidden = path.relative(
+        basePath,
+        path.join(forbiddenPath, 'file.md'),
+      );
+      expect(
+        validateImportPath(relativeToForbidden, basePath, [allowedPath]),
+      ).toBe(false);
+
+      // Path that tries to escape the base directory should be blocked
+      const escapingPath = path.join('..', '..', 'sensitive', 'file.md');
+      expect(validateImportPath(escapingPath, basePath, [basePath])).toBe(
+        false,
+      );
+    });
+
+    it('should handle multiple allowed directories', () => {
+      const basePath = path.resolve(testPath('base'));
+      const allowed1 = path.resolve(testPath('allowed1'));
+      const allowed2 = path.resolve(testPath('allowed2'));
+
+      // File not in any allowed path
+      const otherPath = path.resolve(testPath('other', 'file.md'));
+      expect(
+        validateImportPath(otherPath, basePath, [allowed1, allowed2]),
+      ).toBe(false);
+
+      // File in first allowed path
+      const file1 = path.join(allowed1, 'nested', 'file.md');
+      expect(validateImportPath(file1, basePath, [allowed1, allowed2])).toBe(
+        true,
+      );
+
+      // File in second allowed path
+      const file2 = path.join(allowed2, 'nested', 'file.md');
+      expect(validateImportPath(file2, basePath, [allowed1, allowed2])).toBe(
+        true,
+      );
+
+      // Test with relative path to allowed directory
+      const relativeToAllowed1 = path.relative(basePath, file1);
+      expect(
+        validateImportPath(relativeToAllowed1, basePath, [allowed1, allowed2]),
+      ).toBe(true);
+    });
+
+    it('should handle relative paths correctly', () => {
+      const basePath = path.resolve(testPath('base'));
+      const parentPath = path.resolve(testPath('parent'));
+
+      // Current directory file access
+      expect(validateImportPath('file.md', basePath, [basePath])).toBe(true);
+
+      // Explicit current directory file access
+      expect(validateImportPath('./file.md', basePath, [basePath])).toBe(true);
+
+      // Parent directory access - should be blocked unless parent is in allowed paths
+      const parentFile = path.join(parentPath, 'file.md');
+      const relativeToParent = path.relative(basePath, parentFile);
+      expect(validateImportPath(relativeToParent, basePath, [basePath])).toBe(
+        false,
+      );
+
+      // Parent directory access when parent is in allowed paths
+      expect(
+        validateImportPath(relativeToParent, basePath, [basePath, parentPath]),
+      ).toBe(true);
+
+      // Nested relative path
+      const nestedPath = path.join('nested', 'sub', 'file.md');
+      expect(validateImportPath(nestedPath, basePath, [basePath])).toBe(true);
+    });
+
+    it('should handle absolute paths correctly', () => {
+      const basePath = path.resolve(testPath('base'));
+      const allowedPath = path.resolve(testPath('allowed'));
+      const forbiddenPath = path.resolve(testPath('forbidden'));
+
+      // Allowed path should work - file directly in allowed directory
+      const allowedFilePath = path.join(allowedPath, 'file.md');
+      expect(validateImportPath(allowedFilePath, basePath, [allowedPath])).toBe(
+        true,
+      );
+
+      // Allowed path should work - file in subdirectory of allowed directory
+      const allowedNestedPath = path.join(allowedPath, 'nested', 'file.md');
+      expect(
+        validateImportPath(allowedNestedPath, basePath, [allowedPath]),
+      ).toBe(true);
+
+      // Forbidden path should be blocked
+      const forbiddenFilePath = path.join(forbiddenPath, 'file.md');
+      expect(
+        validateImportPath(forbiddenFilePath, basePath, [allowedPath]),
+      ).toBe(false);
+
+      // Relative path to allowed directory should work
+      const relativeToAllowed = path.relative(basePath, allowedFilePath);
+      expect(
+        validateImportPath(relativeToAllowed, basePath, [allowedPath]),
+      ).toBe(true);
+
+      // Path that resolves to the same file but via different relative segments
+      const dotPath = path.join(
+        '.',
+        '..',
+        path.basename(allowedPath),
+        'file.md',
+      );
+      expect(validateImportPath(dotPath, basePath, [allowedPath])).toBe(true);
+    });
+  });
+});

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

@@ -0,0 +1,418 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { isSubpath } from './paths.js';
+import { marked } from 'marked';
+
+// Simple console logger for import processing
+const logger = {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  debug: (...args: any[]) =>
+    console.debug('[DEBUG] [ImportProcessor]', ...args),
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  warn: (...args: any[]) => console.warn('[WARN] [ImportProcessor]', ...args),
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  error: (...args: any[]) =>
+    console.error('[ERROR] [ImportProcessor]', ...args),
+};
+
+/**
+ * Interface for tracking import processing state to prevent circular imports
+ */
+interface ImportState {
+  processedFiles: Set<string>;
+  maxDepth: number;
+  currentDepth: number;
+  currentFile?: string; // Track the current file being processed
+}
+
+/**
+ * Interface representing a file in the import tree
+ */
+export interface MemoryFile {
+  path: string;
+  imports?: MemoryFile[]; // Direct imports, in the order they were imported
+}
+
+/**
+ * Result of processing imports
+ */
+export interface ProcessImportsResult {
+  content: string;
+  importTree: MemoryFile;
+}
+
+// Helper to find the project root (looks for .git directory)
+async function findProjectRoot(startDir: string): Promise<string> {
+  let currentDir = path.resolve(startDir);
+  while (true) {
+    const gitPath = path.join(currentDir, '.git');
+    try {
+      const stats = await fs.lstat(gitPath);
+      if (stats.isDirectory()) {
+        return currentDir;
+      }
+    } catch {
+      // .git not found, continue to parent
+    }
+    const parentDir = path.dirname(currentDir);
+    if (parentDir === currentDir) {
+      // Reached filesystem root
+      break;
+    }
+    currentDir = parentDir;
+  }
+  // Fallback to startDir if .git not found
+  return path.resolve(startDir);
+}
+
+// Add a type guard for error objects
+function hasMessage(err: unknown): err is { message: string } {
+  return (
+    typeof err === 'object' &&
+    err !== null &&
+    'message' in err &&
+    typeof (err as { message: unknown }).message === 'string'
+  );
+}
+
+// Helper to find all code block and inline code regions using marked
+/**
+ * Finds all import statements in content without using regex
+ * @returns Array of {start, _end, path} objects for each import found
+ */
+function findImports(
+  content: string,
+): Array<{ start: number; _end: number; path: string }> {
+  const imports: Array<{ start: number; _end: number; path: string }> = [];
+  let i = 0;
+  const len = content.length;
+
+  while (i < len) {
+    // Find next @ symbol
+    i = content.indexOf('@', i);
+    if (i === -1) break;
+
+    // Check if it's a word boundary (not part of another word)
+    if (i > 0 && !isWhitespace(content[i - 1])) {
+      i++;
+      continue;
+    }
+
+    // Find the end of the import path (whitespace or newline)
+    let j = i + 1;
+    while (
+      j < len &&
+      !isWhitespace(content[j]) &&
+      content[j] !== '\n' &&
+      content[j] !== '\r'
+    ) {
+      j++;
+    }
+
+    // Extract the path (everything after @)
+    const importPath = content.slice(i + 1, j);
+
+    // Basic validation (starts with ./ or / or letter)
+    if (
+      importPath.length > 0 &&
+      (importPath[0] === '.' ||
+        importPath[0] === '/' ||
+        isLetter(importPath[0]))
+    ) {
+      imports.push({
+        start: i,
+        _end: j,
+        path: importPath,
+      });
+    }
+
+    i = j + 1;
+  }
+
+  return imports;
+}
+
+function isWhitespace(char: string): boolean {
+  return char === ' ' || char === '\t' || char === '\n' || char === '\r';
+}
+
+function isLetter(char: string): boolean {
+  const code = char.charCodeAt(0);
+  return (
+    (code >= 65 && code <= 90) || // A-Z
+    (code >= 97 && code <= 122)
+  ); // a-z
+}
+
+function findCodeRegions(content: string): Array<[number, number]> {
+  const regions: Array<[number, number]> = [];
+  const tokens = marked.lexer(content);
+
+  // Map from raw content to a queue of its start indices in the original content.
+  const rawContentIndices = new Map<string, number[]>();
+
+  function walk(token: { type: string; raw: string; tokens?: unknown[] }) {
+    if (token.type === 'code' || token.type === 'codespan') {
+      if (!rawContentIndices.has(token.raw)) {
+        const indices: number[] = [];
+        let lastIndex = -1;
+        while ((lastIndex = content.indexOf(token.raw, lastIndex + 1)) !== -1) {
+          indices.push(lastIndex);
+        }
+        rawContentIndices.set(token.raw, indices);
+      }
+
+      const indices = rawContentIndices.get(token.raw);
+      if (indices && indices.length > 0) {
+        // Assume tokens are processed in order of appearance.
+        // Dequeue the next available index for this raw content.
+        const idx = indices.shift()!;
+        regions.push([idx, idx + token.raw.length]);
+      }
+    }
+
+    if ('tokens' in token && token.tokens) {
+      for (const child of token.tokens) {
+        walk(child as { type: string; raw: string; tokens?: unknown[] });
+      }
+    }
+  }
+
+  for (const token of tokens) {
+    walk(token);
+  }
+
+  return regions;
+}
+
+/**
+ * Processes import statements in QWEN.md content
+ * Supports @path/to/file syntax for importing content from other files
+ * @param content - The content to process for imports
+ * @param basePath - The directory path where the current file is located
+ * @param debugMode - Whether to enable debug logging
+ * @param importState - State tracking for circular import prevention
+ * @param projectRoot - The project root directory for allowed directories
+ * @param importFormat - The format of the import tree
+ * @returns Processed content with imports resolved and import tree
+ */
+export async function processImports(
+  content: string,
+  basePath: string,
+  debugMode: boolean = false,
+  importState: ImportState = {
+    processedFiles: new Set(),
+    maxDepth: 5,
+    currentDepth: 0,
+  },
+  projectRoot?: string,
+  importFormat: 'flat' | 'tree' = 'tree',
+): Promise<ProcessImportsResult> {
+  if (!projectRoot) {
+    projectRoot = await findProjectRoot(basePath);
+  }
+
+  if (importState.currentDepth >= importState.maxDepth) {
+    if (debugMode) {
+      logger.warn(
+        `Maximum import depth (${importState.maxDepth}) reached. Stopping import processing.`,
+      );
+    }
+    return {
+      content,
+      importTree: { path: importState.currentFile || 'unknown' },
+    };
+  }
+
+  // --- FLAT FORMAT LOGIC ---
+  if (importFormat === 'flat') {
+    // Use a queue to process files in order of first encounter, and a set to avoid duplicates
+    const flatFiles: Array<{ path: string; content: string }> = [];
+    // Track processed files across the entire operation
+    const processedFiles = new Set<string>();
+
+    // Helper to recursively process imports
+    async function processFlat(
+      fileContent: string,
+      fileBasePath: string,
+      filePath: string,
+      depth: number,
+    ) {
+      // Normalize the file path to ensure consistent comparison
+      const normalizedPath = path.normalize(filePath);
+
+      // Skip if already processed
+      if (processedFiles.has(normalizedPath)) return;
+
+      // Mark as processed before processing to prevent infinite recursion
+      processedFiles.add(normalizedPath);
+
+      // Add this file to the flat list
+      flatFiles.push({ path: normalizedPath, content: fileContent });
+
+      // Find imports in this file
+      const codeRegions = findCodeRegions(fileContent);
+      const imports = findImports(fileContent);
+
+      // Process imports in reverse order to handle indices correctly
+      for (let i = imports.length - 1; i >= 0; i--) {
+        const { start, path: importPath } = imports[i];
+
+        // Skip if inside a code region
+        if (
+          codeRegions.some(
+            ([regionStart, regionEnd]) =>
+              start >= regionStart && start < regionEnd,
+          )
+        ) {
+          continue;
+        }
+
+        // Validate import path
+        if (
+          !validateImportPath(importPath, fileBasePath, [projectRoot || ''])
+        ) {
+          continue;
+        }
+
+        const fullPath = path.resolve(fileBasePath, importPath);
+        const normalizedFullPath = path.normalize(fullPath);
+
+        // Skip if already processed
+        if (processedFiles.has(normalizedFullPath)) continue;
+
+        try {
+          await fs.access(fullPath);
+          const importedContent = await fs.readFile(fullPath, 'utf-8');
+
+          // Process the imported file
+          await processFlat(
+            importedContent,
+            path.dirname(fullPath),
+            normalizedFullPath,
+            depth + 1,
+          );
+        } catch (error) {
+          if (debugMode) {
+            logger.warn(
+              `Failed to import ${fullPath}: ${hasMessage(error) ? error.message : 'Unknown error'}`,
+            );
+          }
+          // Continue with other imports even if one fails
+        }
+      }
+    }
+
+    // Start with the root file (current file)
+    const rootPath = path.normalize(
+      importState.currentFile || path.resolve(basePath),
+    );
+    await processFlat(content, basePath, rootPath, 0);
+
+    // Concatenate all unique files in order, Claude-style
+    const flatContent = flatFiles
+      .map(
+        (f) =>
+          `--- File: ${f.path} ---\n${f.content.trim()}\n--- End of File: ${f.path} ---`,
+      )
+      .join('\n\n');
+
+    return {
+      content: flatContent,
+      importTree: { path: rootPath }, // Tree not meaningful in flat mode
+    };
+  }
+
+  // --- TREE FORMAT LOGIC (existing) ---
+  const codeRegions = findCodeRegions(content);
+  let result = '';
+  let lastIndex = 0;
+  const imports: MemoryFile[] = [];
+  const importsList = findImports(content);
+
+  for (const { start, _end, path: importPath } of importsList) {
+    // Add content before this import
+    result += content.substring(lastIndex, start);
+    lastIndex = _end;
+
+    // Skip if inside a code region
+    if (codeRegions.some(([s, e]) => start >= s && start < e)) {
+      result += `@${importPath}`;
+      continue;
+    }
+    // Validate import path to prevent path traversal attacks
+    if (!validateImportPath(importPath, basePath, [projectRoot || ''])) {
+      result += `<!-- Import failed: ${importPath} - Path traversal attempt -->`;
+      continue;
+    }
+    const fullPath = path.resolve(basePath, importPath);
+    if (importState.processedFiles.has(fullPath)) {
+      result += `<!-- File already processed: ${importPath} -->`;
+      continue;
+    }
+    try {
+      await fs.access(fullPath);
+      const fileContent = await fs.readFile(fullPath, 'utf-8');
+      // Mark this file as processed for this import chain
+      const newImportState: ImportState = {
+        ...importState,
+        processedFiles: new Set(importState.processedFiles),
+        currentDepth: importState.currentDepth + 1,
+        currentFile: fullPath,
+      };
+      newImportState.processedFiles.add(fullPath);
+      const imported = await processImports(
+        fileContent,
+        path.dirname(fullPath),
+        debugMode,
+        newImportState,
+        projectRoot,
+        importFormat,
+      );
+      result += `<!-- Imported from: ${importPath} -->\n${imported.content}\n<!-- End of import from: ${importPath} -->`;
+      imports.push(imported.importTree);
+    } catch (err: unknown) {
+      let message = 'Unknown error';
+      if (hasMessage(err)) {
+        message = err.message;
+      } else if (typeof err === 'string') {
+        message = err;
+      }
+      logger.error(`Failed to import ${importPath}: ${message}`);
+      result += `<!-- Import failed: ${importPath} - ${message} -->`;
+    }
+  }
+  // Add any remaining content after the last match
+  result += content.substring(lastIndex);
+
+  return {
+    content: result,
+    importTree: {
+      path: importState.currentFile || 'unknown',
+      imports: imports.length > 0 ? imports : undefined,
+    },
+  };
+}
+
+export function validateImportPath(
+  importPath: string,
+  basePath: string,
+  allowedDirectories: string[],
+): boolean {
+  // Reject URLs
+  if (/^(file|https?):\/\//.test(importPath)) {
+    return false;
+  }
+
+  const resolvedPath = path.resolve(basePath, importPath);
+
+  return allowedDirectories.some((allowedDir) =>
+    isSubpath(allowedDir, resolvedPath),
+  );
+}

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

@@ -0,0 +1,23 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { Content } from '@google/genai';
+
+export function isFunctionResponse(content: Content): boolean {
+  return (
+    content.role === 'user' &&
+    !!content.parts &&
+    content.parts.every((part) => !!part.functionResponse)
+  );
+}
+
+export function isFunctionCall(content: Content): boolean {
+  return (
+    content.role === 'model' &&
+    !!content.parts &&
+    content.parts.every((part) => !!part.functionCall)
+  );
+}

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

@@ -0,0 +1,253 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { describe, it, expect, vi, beforeEach, Mock, afterEach } from 'vitest';
+import { Content, GoogleGenAI, Models } from '@google/genai';
+import { DEFAULT_GEMINI_FLASH_MODEL } from '../config/models.js';
+import { GeminiClient } from '../core/client.js';
+import { Config } from '../config/config.js';
+import { checkNextSpeaker, NextSpeakerResponse } from './nextSpeakerChecker.js';
+import { GeminiChat } from '../core/geminiChat.js';
+
+// Mock GeminiClient and Config constructor
+vi.mock('../core/client.js');
+vi.mock('../config/config.js');
+
+// Define mocks for GoogleGenAI and Models instances that will be used across tests
+const mockModelsInstance = {
+  generateContent: vi.fn(),
+  generateContentStream: vi.fn(),
+  countTokens: vi.fn(),
+  embedContent: vi.fn(),
+  batchEmbedContents: vi.fn(),
+} as unknown as Models;
+
+const mockGoogleGenAIInstance = {
+  getGenerativeModel: vi.fn().mockReturnValue(mockModelsInstance),
+  // Add other methods of GoogleGenAI if they are directly used by GeminiChat constructor or its methods
+} as unknown as GoogleGenAI;
+
+vi.mock('@google/genai', async () => {
+  const actualGenAI =
+    await vi.importActual<typeof import('@google/genai')>('@google/genai');
+  return {
+    ...actualGenAI,
+    GoogleGenAI: vi.fn(() => mockGoogleGenAIInstance), // Mock constructor to return the predefined instance
+    // If Models is instantiated directly in GeminiChat, mock its constructor too
+    // For now, assuming Models instance is obtained via getGenerativeModel
+  };
+});
+
+describe('checkNextSpeaker', () => {
+  let chatInstance: GeminiChat;
+  let mockGeminiClient: GeminiClient;
+  let MockConfig: Mock;
+  const abortSignal = new AbortController().signal;
+
+  beforeEach(() => {
+    MockConfig = vi.mocked(Config);
+    const mockConfigInstance = new MockConfig(
+      'test-api-key',
+      'gemini-pro',
+      false,
+      '.',
+      false,
+      undefined,
+      false,
+      undefined,
+      undefined,
+      undefined,
+    );
+
+    mockGeminiClient = new GeminiClient(mockConfigInstance);
+
+    // Reset mocks before each test to ensure test isolation
+    vi.mocked(mockModelsInstance.generateContent).mockReset();
+    vi.mocked(mockModelsInstance.generateContentStream).mockReset();
+
+    // GeminiChat will receive the mocked instances via the mocked GoogleGenAI constructor
+    chatInstance = new GeminiChat(
+      mockConfigInstance,
+      mockModelsInstance, // This is the instance returned by mockGoogleGenAIInstance.getGenerativeModel
+      {},
+      [], // initial history
+    );
+
+    // Spy on getHistory for chatInstance
+    vi.spyOn(chatInstance, 'getHistory');
+  });
+
+  afterEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('should return null if history is empty', async () => {
+    (chatInstance.getHistory as Mock).mockReturnValue([]);
+    const result = await checkNextSpeaker(
+      chatInstance,
+      mockGeminiClient,
+      abortSignal,
+    );
+    expect(result).toBeNull();
+    expect(mockGeminiClient.generateJson).not.toHaveBeenCalled();
+  });
+
+  it('should return null if the last speaker was the user', async () => {
+    (chatInstance.getHistory as Mock).mockReturnValue([
+      { role: 'user', parts: [{ text: 'Hello' }] },
+    ] as Content[]);
+    const result = await checkNextSpeaker(
+      chatInstance,
+      mockGeminiClient,
+      abortSignal,
+    );
+    expect(result).toBeNull();
+    expect(mockGeminiClient.generateJson).not.toHaveBeenCalled();
+  });
+
+  it("should return { next_speaker: 'model' } when model intends to continue", async () => {
+    (chatInstance.getHistory as Mock).mockReturnValue([
+      { role: 'model', parts: [{ text: 'I will now do something.' }] },
+    ] as Content[]);
+    const mockApiResponse: NextSpeakerResponse = {
+      reasoning: 'Model stated it will do something.',
+      next_speaker: 'model',
+    };
+    (mockGeminiClient.generateJson as Mock).mockResolvedValue(mockApiResponse);
+
+    const result = await checkNextSpeaker(
+      chatInstance,
+      mockGeminiClient,
+      abortSignal,
+    );
+    expect(result).toEqual(mockApiResponse);
+    expect(mockGeminiClient.generateJson).toHaveBeenCalledTimes(1);
+  });
+
+  it("should return { next_speaker: 'user' } when model asks a question", async () => {
+    (chatInstance.getHistory as Mock).mockReturnValue([
+      { role: 'model', parts: [{ text: 'What would you like to do?' }] },
+    ] as Content[]);
+    const mockApiResponse: NextSpeakerResponse = {
+      reasoning: 'Model asked a question.',
+      next_speaker: 'user',
+    };
+    (mockGeminiClient.generateJson as Mock).mockResolvedValue(mockApiResponse);
+
+    const result = await checkNextSpeaker(
+      chatInstance,
+      mockGeminiClient,
+      abortSignal,
+    );
+    expect(result).toEqual(mockApiResponse);
+  });
+
+  it("should return { next_speaker: 'user' } when model makes a statement", async () => {
+    (chatInstance.getHistory as Mock).mockReturnValue([
+      { role: 'model', parts: [{ text: 'This is a statement.' }] },
+    ] as Content[]);
+    const mockApiResponse: NextSpeakerResponse = {
+      reasoning: 'Model made a statement, awaiting user input.',
+      next_speaker: 'user',
+    };
+    (mockGeminiClient.generateJson as Mock).mockResolvedValue(mockApiResponse);
+
+    const result = await checkNextSpeaker(
+      chatInstance,
+      mockGeminiClient,
+      abortSignal,
+    );
+    expect(result).toEqual(mockApiResponse);
+  });
+
+  it('should return null if geminiClient.generateJson throws an error', async () => {
+    const consoleWarnSpy = vi
+      .spyOn(console, 'warn')
+      .mockImplementation(() => {});
+    (chatInstance.getHistory as Mock).mockReturnValue([
+      { role: 'model', parts: [{ text: 'Some model output.' }] },
+    ] as Content[]);
+    (mockGeminiClient.generateJson as Mock).mockRejectedValue(
+      new Error('API Error'),
+    );
+
+    const result = await checkNextSpeaker(
+      chatInstance,
+      mockGeminiClient,
+      abortSignal,
+    );
+    expect(result).toBeNull();
+    consoleWarnSpy.mockRestore();
+  });
+
+  it('should return null if geminiClient.generateJson returns invalid JSON (missing next_speaker)', async () => {
+    (chatInstance.getHistory as Mock).mockReturnValue([
+      { role: 'model', parts: [{ text: 'Some model output.' }] },
+    ] as Content[]);
+    (mockGeminiClient.generateJson as Mock).mockResolvedValue({
+      reasoning: 'This is incomplete.',
+    } as unknown as NextSpeakerResponse); // Type assertion to simulate invalid response
+
+    const result = await checkNextSpeaker(
+      chatInstance,
+      mockGeminiClient,
+      abortSignal,
+    );
+    expect(result).toBeNull();
+  });
+
+  it('should return null if geminiClient.generateJson returns a non-string next_speaker', async () => {
+    (chatInstance.getHistory as Mock).mockReturnValue([
+      { role: 'model', parts: [{ text: 'Some model output.' }] },
+    ] as Content[]);
+    (mockGeminiClient.generateJson as Mock).mockResolvedValue({
+      reasoning: 'Model made a statement, awaiting user input.',
+      next_speaker: 123, // Invalid type
+    } as unknown as NextSpeakerResponse);
+
+    const result = await checkNextSpeaker(
+      chatInstance,
+      mockGeminiClient,
+      abortSignal,
+    );
+    expect(result).toBeNull();
+  });
+
+  it('should return null if geminiClient.generateJson returns an invalid next_speaker string value', async () => {
+    (chatInstance.getHistory as Mock).mockReturnValue([
+      { role: 'model', parts: [{ text: 'Some model output.' }] },
+    ] as Content[]);
+    (mockGeminiClient.generateJson as Mock).mockResolvedValue({
+      reasoning: 'Model made a statement, awaiting user input.',
+      next_speaker: 'neither', // Invalid enum value
+    } as unknown as NextSpeakerResponse);
+
+    const result = await checkNextSpeaker(
+      chatInstance,
+      mockGeminiClient,
+      abortSignal,
+    );
+    expect(result).toBeNull();
+  });
+
+  it('should call generateJson with DEFAULT_GEMINI_FLASH_MODEL', async () => {
+    (chatInstance.getHistory as Mock).mockReturnValue([
+      { role: 'model', parts: [{ text: 'Some model output.' }] },
+    ] as Content[]);
+    const mockApiResponse: NextSpeakerResponse = {
+      reasoning: 'Model made a statement, awaiting user input.',
+      next_speaker: 'user',
+    };
+    (mockGeminiClient.generateJson as Mock).mockResolvedValue(mockApiResponse);
+
+    await checkNextSpeaker(chatInstance, mockGeminiClient, abortSignal);
+
+    expect(mockGeminiClient.generateJson).toHaveBeenCalled();
+    const generateJsonCall = (mockGeminiClient.generateJson as Mock).mock
+      .calls[0];
+    expect(generateJsonCall[3]).toBe(DEFAULT_GEMINI_FLASH_MODEL);
+  });
+});

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

@@ -0,0 +1,133 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { Content } from '@google/genai';
+import { DEFAULT_GEMINI_FLASH_MODEL } from '../config/models.js';
+import { GeminiClient } from '../core/client.js';
+import { GeminiChat } from '../core/geminiChat.js';
+import { isFunctionResponse } from './messageInspectors.js';
+
+const CHECK_PROMPT = `Analyze *only* the content and structure of your immediately preceding response (your last turn in the conversation history). Based *strictly* on that response, determine who should logically speak next: the 'user' or the 'model' (you).
+**Decision Rules (apply in order):**
+1.  **Model Continues:** If your last response explicitly states an immediate next action *you* intend to take (e.g., "Next, I will...", "Now I'll process...", "Moving on to analyze...", indicates an intended tool call that didn't execute), OR if the response seems clearly incomplete (cut off mid-thought without a natural conclusion), then the **'model'** should speak next.
+2.  **Question to User:** If your last response ends with a direct question specifically addressed *to the user*, then the **'user'** should speak next.
+3.  **Waiting for User:** If your last response completed a thought, statement, or task *and* does not meet the criteria for Rule 1 (Model Continues) or Rule 2 (Question to User), it implies a pause expecting user input or reaction. In this case, the **'user'** should speak next.`;
+
+const RESPONSE_SCHEMA: Record<string, unknown> = {
+  type: 'object',
+  properties: {
+    reasoning: {
+      type: 'string',
+      description:
+        "Brief explanation justifying the 'next_speaker' choice based *strictly* on the applicable rule and the content/structure of the preceding turn.",
+    },
+    next_speaker: {
+      type: 'string',
+      enum: ['user', 'model'],
+      description:
+        'Who should speak next based *only* on the preceding turn and the decision rules',
+    },
+  },
+  required: ['reasoning', 'next_speaker'],
+};
+
+export interface NextSpeakerResponse {
+  reasoning: string;
+  next_speaker: 'user' | 'model';
+}
+
+export async function checkNextSpeaker(
+  chat: GeminiChat,
+  geminiClient: GeminiClient,
+  abortSignal: AbortSignal,
+): Promise<NextSpeakerResponse | null> {
+  // We need to capture the curated history because there are many moments when the model will return invalid turns
+  // that when passed back up to the endpoint will break subsequent calls. An example of this is when the model decides
+  // to respond with an empty part collection if you were to send that message back to the server it will respond with
+  // a 400 indicating that model part collections MUST have content.
+  const curatedHistory = chat.getHistory(/* curated */ true);
+
+  // Ensure there's a model response to analyze
+  if (curatedHistory.length === 0) {
+    // Cannot determine next speaker if history is empty.
+    return null;
+  }
+
+  const comprehensiveHistory = chat.getHistory();
+  // If comprehensiveHistory is empty, there is no last message to check.
+  // This case should ideally be caught by the curatedHistory.length check earlier,
+  // but as a safeguard:
+  if (comprehensiveHistory.length === 0) {
+    return null;
+  }
+  const lastComprehensiveMessage =
+    comprehensiveHistory[comprehensiveHistory.length - 1];
+
+  // If the last message is a user message containing only function_responses,
+  // then the model should speak next.
+  if (
+    lastComprehensiveMessage &&
+    isFunctionResponse(lastComprehensiveMessage)
+  ) {
+    return {
+      reasoning:
+        'The last message was a function response, so the model should speak next.',
+      next_speaker: 'model',
+    };
+  }
+
+  if (
+    lastComprehensiveMessage &&
+    lastComprehensiveMessage.role === 'model' &&
+    lastComprehensiveMessage.parts &&
+    lastComprehensiveMessage.parts.length === 0
+  ) {
+    lastComprehensiveMessage.parts.push({ text: '' });
+    return {
+      reasoning:
+        'The last message was a filler model message with no content (nothing for user to act on), model should speak next.',
+      next_speaker: 'model',
+    };
+  }
+
+  // Things checked out. Let's proceed to potentially making an LLM request.
+
+  const lastMessage = curatedHistory[curatedHistory.length - 1];
+  if (!lastMessage || lastMessage.role !== 'model') {
+    // Cannot determine next speaker if the last turn wasn't from the model
+    // or if history is empty.
+    return null;
+  }
+
+  const contents: Content[] = [
+    ...curatedHistory,
+    { role: 'user', parts: [{ text: CHECK_PROMPT }] },
+  ];
+
+  try {
+    const parsedResponse = (await geminiClient.generateJson(
+      contents,
+      RESPONSE_SCHEMA,
+      abortSignal,
+      DEFAULT_GEMINI_FLASH_MODEL,
+    )) as unknown as NextSpeakerResponse;
+
+    if (
+      parsedResponse &&
+      parsedResponse.next_speaker &&
+      ['user', 'model'].includes(parsedResponse.next_speaker)
+    ) {
+      return parsedResponse;
+    }
+    return null;
+  } catch (error) {
+    console.warn(
+      'Failed to talk to Gemini endpoint when seeing if conversation should continue.',
+      error,
+    );
+    return null;
+  }
+}

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

@@ -0,0 +1,135 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import * as path from 'node:path';
+import { promises as fs } from 'node:fs';
+import { v4 as uuidv4 } from 'uuid';
+import * as os from 'os';
+
+/**
+ * Logger specifically for OpenAI API requests and responses
+ */
+export class OpenAILogger {
+  private logDir: string;
+  private initialized: boolean = false;
+
+  /**
+   * Creates a new OpenAI logger
+   * @param customLogDir Optional custom log directory path
+   */
+  constructor(customLogDir?: string) {
+    this.logDir = customLogDir || path.join(process.cwd(), 'logs', 'openai');
+  }
+
+  /**
+   * Initialize the logger by creating the log directory if it doesn't exist
+   */
+  async initialize(): Promise<void> {
+    if (this.initialized) return;
+
+    try {
+      await fs.mkdir(this.logDir, { recursive: true });
+      this.initialized = true;
+    } catch (error) {
+      console.error('Failed to initialize OpenAI logger:', error);
+      throw new Error(`Failed to initialize OpenAI logger: ${error}`);
+    }
+  }
+
+  /**
+   * Logs an OpenAI API request and its response
+   * @param request The request sent to OpenAI
+   * @param response The response received from OpenAI
+   * @param error Optional error if the request failed
+   * @returns The file path where the log was written
+   */
+  async logInteraction(
+    request: unknown,
+    response?: unknown,
+    error?: Error,
+  ): Promise<string> {
+    if (!this.initialized) {
+      await this.initialize();
+    }
+
+    const timestamp = new Date().toISOString().replace(/:/g, '-');
+    const id = uuidv4().slice(0, 8);
+    const filename = `openai-${timestamp}-${id}.json`;
+    const filePath = path.join(this.logDir, filename);
+
+    const logData = {
+      timestamp: new Date().toISOString(),
+      request,
+      response: response || null,
+      error: error
+        ? {
+            message: error.message,
+            stack: error.stack,
+          }
+        : null,
+      system: {
+        hostname: os.hostname(),
+        platform: os.platform(),
+        release: os.release(),
+        nodeVersion: process.version,
+      },
+    };
+
+    try {
+      await fs.writeFile(filePath, JSON.stringify(logData, null, 2), 'utf-8');
+      return filePath;
+    } catch (writeError) {
+      console.error('Failed to write OpenAI log file:', writeError);
+      throw new Error(`Failed to write OpenAI log file: ${writeError}`);
+    }
+  }
+
+  /**
+   * Get all logged interactions
+   * @param limit Optional limit on the number of log files to return (sorted by most recent first)
+   * @returns Array of log file paths
+   */
+  async getLogFiles(limit?: number): Promise<string[]> {
+    if (!this.initialized) {
+      await this.initialize();
+    }
+
+    try {
+      const files = await fs.readdir(this.logDir);
+      const logFiles = files
+        .filter((file) => file.startsWith('openai-') && file.endsWith('.json'))
+        .map((file) => path.join(this.logDir, file))
+        .sort()
+        .reverse();
+
+      return limit ? logFiles.slice(0, limit) : logFiles;
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code === 'ENOENT') {
+        return [];
+      }
+      console.error('Failed to read OpenAI log directory:', error);
+      return [];
+    }
+  }
+
+  /**
+   * Read a specific log file
+   * @param filePath The path to the log file
+   * @returns The log file content
+   */
+  async readLogFile(filePath: string): Promise<unknown> {
+    try {
+      const content = await fs.readFile(filePath, 'utf-8');
+      return JSON.parse(content);
+    } catch (error) {
+      console.error(`Failed to read log file ${filePath}:`, error);
+      throw new Error(`Failed to read log file: ${error}`);
+    }
+  }
+}
+
+// Create a singleton instance for easy import
+export const openaiLogger = new OpenAILogger();

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

@@ -0,0 +1,166 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { describe, it, expect } from 'vitest';
+import { partToString, getResponseText } from './partUtils.js';
+import { GenerateContentResponse, Part } from '@google/genai';
+
+const mockResponse = (
+  parts?: Array<{ text?: string; functionCall?: unknown }>,
+): GenerateContentResponse => ({
+  candidates: parts
+    ? [{ content: { parts: parts as Part[], role: 'model' }, index: 0 }]
+    : [],
+  promptFeedback: { safetyRatings: [] },
+  text: undefined,
+  data: undefined,
+  functionCalls: undefined,
+  executableCode: undefined,
+  codeExecutionResult: undefined,
+});
+
+describe('partUtils', () => {
+  describe('partToString (default behavior)', () => {
+    it('should return empty string for undefined or null', () => {
+      // @ts-expect-error Testing invalid input
+      expect(partToString(undefined)).toBe('');
+      // @ts-expect-error Testing invalid input
+      expect(partToString(null)).toBe('');
+    });
+
+    it('should return string input unchanged', () => {
+      expect(partToString('hello')).toBe('hello');
+    });
+
+    it('should concatenate strings from an array', () => {
+      expect(partToString(['a', 'b'])).toBe('ab');
+    });
+
+    it('should return text property when provided a text part', () => {
+      expect(partToString({ text: 'hi' })).toBe('hi');
+    });
+
+    it('should return empty string for non-text parts', () => {
+      const part: Part = { inlineData: { mimeType: 'image/png', data: '' } };
+      expect(partToString(part)).toBe('');
+      const part2: Part = { functionCall: { name: 'test' } };
+      expect(partToString(part2)).toBe('');
+    });
+  });
+
+  describe('partToString (verbose)', () => {
+    const verboseOptions = { verbose: true };
+
+    it('should return empty string for undefined or null', () => {
+      // @ts-expect-error Testing invalid input
+      expect(partToString(undefined, verboseOptions)).toBe('');
+      // @ts-expect-error Testing invalid input
+      expect(partToString(null, verboseOptions)).toBe('');
+    });
+
+    it('should return string input unchanged', () => {
+      expect(partToString('hello', verboseOptions)).toBe('hello');
+    });
+
+    it('should join parts if the value is an array', () => {
+      const parts = ['hello', { text: ' world' }];
+      expect(partToString(parts, verboseOptions)).toBe('hello world');
+    });
+
+    it('should return the text property if the part is an object with text', () => {
+      const part: Part = { text: 'hello world' };
+      expect(partToString(part, verboseOptions)).toBe('hello world');
+    });
+
+    it('should return descriptive string for videoMetadata part', () => {
+      const part = { videoMetadata: {} } as Part;
+      expect(partToString(part, verboseOptions)).toBe('[Video Metadata]');
+    });
+
+    it('should return descriptive string for thought part', () => {
+      const part = { thought: 'thinking' } as unknown as Part;
+      expect(partToString(part, verboseOptions)).toBe('[Thought: thinking]');
+    });
+
+    it('should return descriptive string for codeExecutionResult part', () => {
+      const part = { codeExecutionResult: {} } as Part;
+      expect(partToString(part, verboseOptions)).toBe(
+        '[Code Execution Result]',
+      );
+    });
+
+    it('should return descriptive string for executableCode part', () => {
+      const part = { executableCode: {} } as Part;
+      expect(partToString(part, verboseOptions)).toBe('[Executable Code]');
+    });
+
+    it('should return descriptive string for fileData part', () => {
+      const part = { fileData: {} } as Part;
+      expect(partToString(part, verboseOptions)).toBe('[File Data]');
+    });
+
+    it('should return descriptive string for functionCall part', () => {
+      const part = { functionCall: { name: 'myFunction' } } as Part;
+      expect(partToString(part, verboseOptions)).toBe(
+        '[Function Call: myFunction]',
+      );
+    });
+
+    it('should return descriptive string for functionResponse part', () => {
+      const part = { functionResponse: { name: 'myFunction' } } as Part;
+      expect(partToString(part, verboseOptions)).toBe(
+        '[Function Response: myFunction]',
+      );
+    });
+
+    it('should return descriptive string for inlineData part', () => {
+      const part = { inlineData: { mimeType: 'image/png', data: '' } } as Part;
+      expect(partToString(part, verboseOptions)).toBe('<image/png>');
+    });
+
+    it('should return an empty string for an unknown part type', () => {
+      const part: Part = {};
+      expect(partToString(part, verboseOptions)).toBe('');
+    });
+
+    it('should handle complex nested arrays with various part types', () => {
+      const parts = [
+        'start ',
+        { text: 'middle' },
+        [
+          { functionCall: { name: 'func1' } },
+          ' end',
+          { inlineData: { mimeType: 'audio/mp3', data: '' } },
+        ],
+      ];
+      expect(partToString(parts as Part, verboseOptions)).toBe(
+        'start middle[Function Call: func1] end<audio/mp3>',
+      );
+    });
+  });
+
+  describe('getResponseText', () => {
+    it('should return null when no candidates exist', () => {
+      const response = mockResponse(undefined);
+      expect(getResponseText(response)).toBeNull();
+    });
+
+    it('should return concatenated text from first candidate', () => {
+      const result = mockResponse([{ text: 'a' }, { text: 'b' }]);
+      expect(getResponseText(result)).toBe('ab');
+    });
+
+    it('should ignore parts without text', () => {
+      const result = mockResponse([{ functionCall: {} }, { text: 'hello' }]);
+      expect(getResponseText(result)).toBe('hello');
+    });
+
+    it('should return null when candidate has no parts', () => {
+      const result = mockResponse([]);
+      expect(getResponseText(result)).toBeNull();
+    });
+  });
+});

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

@@ -0,0 +1,85 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { GenerateContentResponse, PartListUnion, Part } from '@google/genai';
+
+/**
+ * Converts a PartListUnion into a string.
+ * If verbose is true, includes summary representations of non-text parts.
+ */
+export function partToString(
+  value: PartListUnion,
+  options?: { verbose?: boolean },
+): string {
+  if (!value) {
+    return '';
+  }
+  if (typeof value === 'string') {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    return value.map((part) => partToString(part, options)).join('');
+  }
+
+  // Cast to Part, assuming it might contain project-specific fields
+  const part = value as Part & {
+    videoMetadata?: unknown;
+    thought?: string;
+    codeExecutionResult?: unknown;
+    executableCode?: unknown;
+  };
+
+  if (options?.verbose) {
+    if (part.videoMetadata !== undefined) {
+      return `[Video Metadata]`;
+    }
+    if (part.thought !== undefined) {
+      return `[Thought: ${part.thought}]`;
+    }
+    if (part.codeExecutionResult !== undefined) {
+      return `[Code Execution Result]`;
+    }
+    if (part.executableCode !== undefined) {
+      return `[Executable Code]`;
+    }
+
+    // Standard Part fields
+    if (part.fileData !== undefined) {
+      return `[File Data]`;
+    }
+    if (part.functionCall !== undefined) {
+      return `[Function Call: ${part.functionCall.name}]`;
+    }
+    if (part.functionResponse !== undefined) {
+      return `[Function Response: ${part.functionResponse.name}]`;
+    }
+    if (part.inlineData !== undefined) {
+      return `<${part.inlineData.mimeType}>`;
+    }
+  }
+
+  return part.text ?? '';
+}
+
+export function getResponseText(
+  response: GenerateContentResponse,
+): string | null {
+  if (response.candidates && response.candidates.length > 0) {
+    const candidate = response.candidates[0];
+
+    if (
+      candidate.content &&
+      candidate.content.parts &&
+      candidate.content.parts.length > 0
+    ) {
+      return candidate.content.parts
+        .filter((part) => part.text)
+        .map((part) => part.text)
+        .join('');
+    }
+  }
+  return null;
+}

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

@@ -0,0 +1,316 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+import { escapePath, unescapePath, isSubpath } from './paths.js';
+
+describe('escapePath', () => {
+  it('should escape spaces', () => {
+    expect(escapePath('my file.txt')).toBe('my\\ file.txt');
+  });
+
+  it('should escape tabs', () => {
+    expect(escapePath('file\twith\ttabs.txt')).toBe('file\\\twith\\\ttabs.txt');
+  });
+
+  it('should escape parentheses', () => {
+    expect(escapePath('file(1).txt')).toBe('file\\(1\\).txt');
+  });
+
+  it('should escape square brackets', () => {
+    expect(escapePath('file[backup].txt')).toBe('file\\[backup\\].txt');
+  });
+
+  it('should escape curly braces', () => {
+    expect(escapePath('file{temp}.txt')).toBe('file\\{temp\\}.txt');
+  });
+
+  it('should escape semicolons', () => {
+    expect(escapePath('file;name.txt')).toBe('file\\;name.txt');
+  });
+
+  it('should escape ampersands', () => {
+    expect(escapePath('file&name.txt')).toBe('file\\&name.txt');
+  });
+
+  it('should escape pipes', () => {
+    expect(escapePath('file|name.txt')).toBe('file\\|name.txt');
+  });
+
+  it('should escape asterisks', () => {
+    expect(escapePath('file*.txt')).toBe('file\\*.txt');
+  });
+
+  it('should escape question marks', () => {
+    expect(escapePath('file?.txt')).toBe('file\\?.txt');
+  });
+
+  it('should escape dollar signs', () => {
+    expect(escapePath('file$name.txt')).toBe('file\\$name.txt');
+  });
+
+  it('should escape backticks', () => {
+    expect(escapePath('file`name.txt')).toBe('file\\`name.txt');
+  });
+
+  it('should escape single quotes', () => {
+    expect(escapePath("file'name.txt")).toBe("file\\'name.txt");
+  });
+
+  it('should escape double quotes', () => {
+    expect(escapePath('file"name.txt')).toBe('file\\"name.txt');
+  });
+
+  it('should escape hash symbols', () => {
+    expect(escapePath('file#name.txt')).toBe('file\\#name.txt');
+  });
+
+  it('should escape exclamation marks', () => {
+    expect(escapePath('file!name.txt')).toBe('file\\!name.txt');
+  });
+
+  it('should escape tildes', () => {
+    expect(escapePath('file~name.txt')).toBe('file\\~name.txt');
+  });
+
+  it('should escape less than and greater than signs', () => {
+    expect(escapePath('file<name>.txt')).toBe('file\\<name\\>.txt');
+  });
+
+  it('should handle multiple special characters', () => {
+    expect(escapePath('my file (backup) [v1.2].txt')).toBe(
+      'my\\ file\\ \\(backup\\)\\ \\[v1.2\\].txt',
+    );
+  });
+
+  it('should not double-escape already escaped characters', () => {
+    expect(escapePath('my\\ file.txt')).toBe('my\\ file.txt');
+    expect(escapePath('file\\(name\\).txt')).toBe('file\\(name\\).txt');
+  });
+
+  it('should handle escaped backslashes correctly', () => {
+    // Double backslash (escaped backslash) followed by space should escape the space
+    expect(escapePath('path\\\\ file.txt')).toBe('path\\\\\\ file.txt');
+    // Triple backslash (escaped backslash + escaping backslash) followed by space should not double-escape
+    expect(escapePath('path\\\\\\ file.txt')).toBe('path\\\\\\ file.txt');
+    // Quadruple backslash (two escaped backslashes) followed by space should escape the space
+    expect(escapePath('path\\\\\\\\ file.txt')).toBe('path\\\\\\\\\\ file.txt');
+  });
+
+  it('should handle complex escaped backslash scenarios', () => {
+    // Escaped backslash before special character that needs escaping
+    expect(escapePath('file\\\\(test).txt')).toBe('file\\\\\\(test\\).txt');
+    // Multiple escaped backslashes
+    expect(escapePath('path\\\\\\\\with space.txt')).toBe(
+      'path\\\\\\\\with\\ space.txt',
+    );
+  });
+
+  it('should handle paths without special characters', () => {
+    expect(escapePath('normalfile.txt')).toBe('normalfile.txt');
+    expect(escapePath('path/to/normalfile.txt')).toBe('path/to/normalfile.txt');
+  });
+
+  it('should handle complex real-world examples', () => {
+    expect(escapePath('My Documents/Project (2024)/file [backup].txt')).toBe(
+      'My\\ Documents/Project\\ \\(2024\\)/file\\ \\[backup\\].txt',
+    );
+    expect(escapePath('file with $special &chars!.txt')).toBe(
+      'file\\ with\\ \\$special\\ \\&chars\\!.txt',
+    );
+  });
+
+  it('should handle empty strings', () => {
+    expect(escapePath('')).toBe('');
+  });
+
+  it('should handle paths with only special characters', () => {
+    expect(escapePath(' ()[]{};&|*?$`\'"#!~<>')).toBe(
+      '\\ \\(\\)\\[\\]\\{\\}\\;\\&\\|\\*\\?\\$\\`\\\'\\"\\#\\!\\~\\<\\>',
+    );
+  });
+});
+
+describe('unescapePath', () => {
+  it('should unescape spaces', () => {
+    expect(unescapePath('my\\ file.txt')).toBe('my file.txt');
+  });
+
+  it('should unescape tabs', () => {
+    expect(unescapePath('file\\\twith\\\ttabs.txt')).toBe(
+      'file\twith\ttabs.txt',
+    );
+  });
+
+  it('should unescape parentheses', () => {
+    expect(unescapePath('file\\(1\\).txt')).toBe('file(1).txt');
+  });
+
+  it('should unescape square brackets', () => {
+    expect(unescapePath('file\\[backup\\].txt')).toBe('file[backup].txt');
+  });
+
+  it('should unescape curly braces', () => {
+    expect(unescapePath('file\\{temp\\}.txt')).toBe('file{temp}.txt');
+  });
+
+  it('should unescape multiple special characters', () => {
+    expect(unescapePath('my\\ file\\ \\(backup\\)\\ \\[v1.2\\].txt')).toBe(
+      'my file (backup) [v1.2].txt',
+    );
+  });
+
+  it('should handle paths without escaped characters', () => {
+    expect(unescapePath('normalfile.txt')).toBe('normalfile.txt');
+    expect(unescapePath('path/to/normalfile.txt')).toBe(
+      'path/to/normalfile.txt',
+    );
+  });
+
+  it('should handle all special characters', () => {
+    expect(
+      unescapePath(
+        '\\ \\(\\)\\[\\]\\{\\}\\;\\&\\|\\*\\?\\$\\`\\\'\\"\\#\\!\\~\\<\\>',
+      ),
+    ).toBe(' ()[]{};&|*?$`\'"#!~<>');
+  });
+
+  it('should be the inverse of escapePath', () => {
+    const testCases = [
+      'my file.txt',
+      'file(1).txt',
+      'file[backup].txt',
+      'My Documents/Project (2024)/file [backup].txt',
+      'file with $special &chars!.txt',
+      ' ()[]{};&|*?$`\'"#!~<>',
+      'file\twith\ttabs.txt',
+    ];
+
+    testCases.forEach((testCase) => {
+      expect(unescapePath(escapePath(testCase))).toBe(testCase);
+    });
+  });
+
+  it('should handle empty strings', () => {
+    expect(unescapePath('')).toBe('');
+  });
+
+  it('should not affect backslashes not followed by special characters', () => {
+    expect(unescapePath('file\\name.txt')).toBe('file\\name.txt');
+    expect(unescapePath('path\\to\\file.txt')).toBe('path\\to\\file.txt');
+  });
+
+  it('should handle escaped backslashes in unescaping', () => {
+    // Should correctly unescape when there are escaped backslashes
+    expect(unescapePath('path\\\\\\ file.txt')).toBe('path\\\\ file.txt');
+    expect(unescapePath('path\\\\\\\\\\ file.txt')).toBe(
+      'path\\\\\\\\ file.txt',
+    );
+    expect(unescapePath('file\\\\\\(test\\).txt')).toBe('file\\\\(test).txt');
+  });
+});
+
+describe('isSubpath', () => {
+  it('should return true for a direct subpath', () => {
+    expect(isSubpath('/a/b', '/a/b/c')).toBe(true);
+  });
+
+  it('should return true for the same path', () => {
+    expect(isSubpath('/a/b', '/a/b')).toBe(true);
+  });
+
+  it('should return false for a parent path', () => {
+    expect(isSubpath('/a/b/c', '/a/b')).toBe(false);
+  });
+
+  it('should return false for a completely different path', () => {
+    expect(isSubpath('/a/b', '/x/y')).toBe(false);
+  });
+
+  it('should handle relative paths', () => {
+    expect(isSubpath('a/b', 'a/b/c')).toBe(true);
+    expect(isSubpath('a/b', 'a/c')).toBe(false);
+  });
+
+  it('should handle paths with ..', () => {
+    expect(isSubpath('/a/b', '/a/b/../b/c')).toBe(true);
+    expect(isSubpath('/a/b', '/a/c/../b')).toBe(true);
+  });
+
+  it('should handle root paths', () => {
+    expect(isSubpath('/', '/a')).toBe(true);
+    expect(isSubpath('/a', '/')).toBe(false);
+  });
+
+  it('should handle trailing slashes', () => {
+    expect(isSubpath('/a/b/', '/a/b/c')).toBe(true);
+    expect(isSubpath('/a/b', '/a/b/c/')).toBe(true);
+    expect(isSubpath('/a/b/', '/a/b/c/')).toBe(true);
+  });
+});
+
+describe('isSubpath on Windows', () => {
+  const originalPlatform = process.platform;
+
+  beforeAll(() => {
+    Object.defineProperty(process, 'platform', {
+      value: 'win32',
+    });
+  });
+
+  afterAll(() => {
+    Object.defineProperty(process, 'platform', {
+      value: originalPlatform,
+    });
+  });
+
+  it('should return true for a direct subpath on Windows', () => {
+    expect(isSubpath('C:\\Users\\Test', 'C:\\Users\\Test\\file.txt')).toBe(
+      true,
+    );
+  });
+
+  it('should return true for the same path on Windows', () => {
+    expect(isSubpath('C:\\Users\\Test', 'C:\\Users\\Test')).toBe(true);
+  });
+
+  it('should return false for a parent path on Windows', () => {
+    expect(isSubpath('C:\\Users\\Test\\file.txt', 'C:\\Users\\Test')).toBe(
+      false,
+    );
+  });
+
+  it('should return false for a different drive on Windows', () => {
+    expect(isSubpath('C:\\Users\\Test', 'D:\\Users\\Test')).toBe(false);
+  });
+
+  it('should be case-insensitive for drive letters on Windows', () => {
+    expect(isSubpath('c:\\Users\\Test', 'C:\\Users\\Test\\file.txt')).toBe(
+      true,
+    );
+  });
+
+  it('should be case-insensitive for path components on Windows', () => {
+    expect(isSubpath('C:\\Users\\Test', 'c:\\users\\test\\file.txt')).toBe(
+      true,
+    );
+  });
+
+  it('should handle mixed slashes on Windows', () => {
+    expect(isSubpath('C:/Users/Test', 'C:\\Users\\Test\\file.txt')).toBe(true);
+  });
+
+  it('should handle trailing slashes on Windows', () => {
+    expect(isSubpath('C:\\Users\\Test\\', 'C:\\Users\\Test\\file.txt')).toBe(
+      true,
+    );
+  });
+
+  it('should handle relative paths correctly on Windows', () => {
+    expect(isSubpath('Users\\Test', 'Users\\Test\\file.txt')).toBe(true);
+    expect(isSubpath('Users\\Test\\file.txt', 'Users\\Test')).toBe(false);
+  });
+});

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

@@ -0,0 +1,222 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import path from 'node:path';
+import os from 'os';
+import * as crypto from 'crypto';
+
+export const QWEN_DIR = '.qwen';
+export const GOOGLE_ACCOUNTS_FILENAME = 'google_accounts.json';
+const TMP_DIR_NAME = 'tmp';
+const COMMANDS_DIR_NAME = 'commands';
+
+/**
+ * Special characters that need to be escaped in file paths for shell compatibility.
+ * Includes: spaces, parentheses, brackets, braces, semicolons, ampersands, pipes,
+ * asterisks, question marks, dollar signs, backticks, quotes, hash, and other shell metacharacters.
+ */
+export const SHELL_SPECIAL_CHARS = /[ \t()[\]{};|*?$`'"#&<>!~]/;
+
+/**
+ * Replaces the home directory with a tilde.
+ * @param path - The path to tildeify.
+ * @returns The tildeified path.
+ */
+export function tildeifyPath(path: string): string {
+  const homeDir = os.homedir();
+  if (path.startsWith(homeDir)) {
+    return path.replace(homeDir, '~');
+  }
+  return path;
+}
+
+/**
+ * Shortens a path string if it exceeds maxLen, prioritizing the start and end segments.
+ * Example: /path/to/a/very/long/file.txt -> /path/.../long/file.txt
+ */
+export function shortenPath(filePath: string, maxLen: number = 35): string {
+  if (filePath.length <= maxLen) {
+    return filePath;
+  }
+
+  const parsedPath = path.parse(filePath);
+  const root = parsedPath.root;
+  const separator = path.sep;
+
+  // Get segments of the path *after* the root
+  const relativePath = filePath.substring(root.length);
+  const segments = relativePath.split(separator).filter((s) => s !== ''); // Filter out empty segments
+
+  // Handle cases with no segments after root (e.g., "/", "C:\") or only one segment
+  if (segments.length <= 1) {
+    // Fall back to simple start/end truncation for very short paths or single segments
+    const keepLen = Math.floor((maxLen - 3) / 2);
+    // Ensure keepLen is not negative if maxLen is very small
+    if (keepLen <= 0) {
+      return filePath.substring(0, maxLen - 3) + '...';
+    }
+    const start = filePath.substring(0, keepLen);
+    const end = filePath.substring(filePath.length - keepLen);
+    return `${start}...${end}`;
+  }
+
+  const firstDir = segments[0];
+  const lastSegment = segments[segments.length - 1];
+  const startComponent = root + firstDir;
+
+  const endPartSegments: string[] = [];
+  // Base length: separator + "..." + lastDir
+  let currentLength = separator.length + lastSegment.length;
+
+  // Iterate backwards through segments (excluding the first one)
+  for (let i = segments.length - 2; i >= 0; i--) {
+    const segment = segments[i];
+    // Length needed if we add this segment: current + separator + segment
+    const lengthWithSegment = currentLength + separator.length + segment.length;
+
+    if (lengthWithSegment <= maxLen) {
+      endPartSegments.unshift(segment); // Add to the beginning of the end part
+      currentLength = lengthWithSegment;
+    } else {
+      break;
+    }
+  }
+
+  let result = endPartSegments.join(separator) + separator + lastSegment;
+
+  if (currentLength > maxLen) {
+    return result;
+  }
+
+  // Construct the final path
+  result = startComponent + separator + result;
+
+  // As a final check, if the result is somehow still too long
+  // truncate the result string from the beginning, prefixing with "...".
+  if (result.length > maxLen) {
+    return '...' + result.substring(result.length - maxLen - 3);
+  }
+
+  return result;
+}
+
+/**
+ * Calculates the relative path from a root directory to a target path.
+ * Ensures both paths are resolved before calculating.
+ * Returns '.' if the target path is the same as the root directory.
+ *
+ * @param targetPath The absolute or relative path to make relative.
+ * @param rootDirectory The absolute path of the directory to make the target path relative to.
+ * @returns The relative path from rootDirectory to targetPath.
+ */
+export function makeRelative(
+  targetPath: string,
+  rootDirectory: string,
+): string {
+  const resolvedTargetPath = path.resolve(targetPath);
+  const resolvedRootDirectory = path.resolve(rootDirectory);
+
+  const relativePath = path.relative(resolvedRootDirectory, resolvedTargetPath);
+
+  // If the paths are the same, path.relative returns '', return '.' instead
+  return relativePath || '.';
+}
+
+/**
+ * Escapes special characters in a file path like macOS terminal does.
+ * Escapes: spaces, parentheses, brackets, braces, semicolons, ampersands, pipes,
+ * asterisks, question marks, dollar signs, backticks, quotes, hash, and other shell metacharacters.
+ */
+export function escapePath(filePath: string): string {
+  let result = '';
+  for (let i = 0; i < filePath.length; i++) {
+    const char = filePath[i];
+
+    // Count consecutive backslashes before this character
+    let backslashCount = 0;
+    for (let j = i - 1; j >= 0 && filePath[j] === '\\'; j--) {
+      backslashCount++;
+    }
+
+    // Character is already escaped if there's an odd number of backslashes before it
+    const isAlreadyEscaped = backslashCount % 2 === 1;
+
+    // Only escape if not already escaped
+    if (!isAlreadyEscaped && SHELL_SPECIAL_CHARS.test(char)) {
+      result += '\\' + char;
+    } else {
+      result += char;
+    }
+  }
+  return result;
+}
+
+/**
+ * Unescapes special characters in a file path.
+ * Removes backslash escaping from shell metacharacters.
+ */
+export function unescapePath(filePath: string): string {
+  return filePath.replace(
+    new RegExp(`\\\\([${SHELL_SPECIAL_CHARS.source.slice(1, -1)}])`, 'g'),
+    '$1',
+  );
+}
+
+/**
+ * Generates a unique hash for a project based on its root path.
+ * @param projectRoot The absolute path to the project's root directory.
+ * @returns A SHA256 hash of the project root path.
+ */
+export function getProjectHash(projectRoot: string): string {
+  return crypto.createHash('sha256').update(projectRoot).digest('hex');
+}
+
+/**
+ * Generates a unique temporary directory path for a project.
+ * @param projectRoot The absolute path to the project's root directory.
+ * @returns The path to the project's temporary directory.
+ */
+export function getProjectTempDir(projectRoot: string): string {
+  const hash = getProjectHash(projectRoot);
+  return path.join(os.homedir(), QWEN_DIR, TMP_DIR_NAME, hash);
+}
+
+/**
+ * Returns the absolute path to the user-level commands directory.
+ * @returns The path to the user's commands directory.
+ */
+export function getUserCommandsDir(): string {
+  return path.join(os.homedir(), QWEN_DIR, COMMANDS_DIR_NAME);
+}
+
+/**
+ * Returns the absolute path to the project-level commands directory.
+ * @param projectRoot The absolute path to the project's root directory.
+ * @returns The path to the project's commands directory.
+ */
+export function getProjectCommandsDir(projectRoot: string): string {
+  return path.join(projectRoot, QWEN_DIR, COMMANDS_DIR_NAME);
+}
+
+/**
+ * Checks if a path is a subpath of another path.
+ * @param parentPath The parent path.
+ * @param childPath The child path.
+ * @returns True if childPath is a subpath of parentPath, false otherwise.
+ */
+export function isSubpath(parentPath: string, childPath: string): boolean {
+  const isWindows = os.platform() === 'win32';
+  const pathModule = isWindows ? path.win32 : path;
+
+  // On Windows, path.relative is case-insensitive. On POSIX, it's case-sensitive.
+  const relative = pathModule.relative(parentPath, childPath);
+
+  return (
+    !relative.startsWith(`..${pathModule.sep}`) &&
+    relative !== '..' &&
+    !pathModule.isAbsolute(relative)
+  );
+}

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

@@ -0,0 +1,194 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { describe, it, expect } from 'vitest';
+import {
+  isQwenQuotaExceededError,
+  isQwenThrottlingError,
+  isProQuotaExceededError,
+  isGenericQuotaExceededError,
+  isApiError,
+  isStructuredError,
+  type ApiError,
+} from './quotaErrorDetection.js';
+
+describe('quotaErrorDetection', () => {
+  describe('isQwenQuotaExceededError', () => {
+    it('should detect insufficient_quota error message', () => {
+      const error = new Error('insufficient_quota');
+      expect(isQwenQuotaExceededError(error)).toBe(true);
+    });
+
+    it('should detect free allocated quota exceeded error message', () => {
+      const error = new Error('Free allocated quota exceeded.');
+      expect(isQwenQuotaExceededError(error)).toBe(true);
+    });
+
+    it('should detect quota exceeded error message', () => {
+      const error = new Error('quota exceeded');
+      expect(isQwenQuotaExceededError(error)).toBe(true);
+    });
+
+    it('should detect quota exceeded in string error', () => {
+      const error = 'insufficient_quota';
+      expect(isQwenQuotaExceededError(error)).toBe(true);
+    });
+
+    it('should detect quota exceeded in structured error', () => {
+      const error = { message: 'Free allocated quota exceeded.', status: 429 };
+      expect(isQwenQuotaExceededError(error)).toBe(true);
+    });
+
+    it('should detect quota exceeded in API error', () => {
+      const error: ApiError = {
+        error: {
+          code: 429,
+          message: 'insufficient_quota',
+          status: 'RESOURCE_EXHAUSTED',
+          details: [],
+        },
+      };
+      expect(isQwenQuotaExceededError(error)).toBe(true);
+    });
+
+    it('should not detect throttling errors as quota exceeded', () => {
+      const error = new Error('requests throttling triggered');
+      expect(isQwenQuotaExceededError(error)).toBe(false);
+    });
+
+    it('should not detect unrelated errors', () => {
+      const error = new Error('Network error');
+      expect(isQwenQuotaExceededError(error)).toBe(false);
+    });
+  });
+
+  describe('isQwenThrottlingError', () => {
+    it('should detect throttling error with 429 status', () => {
+      const error = { message: 'throttling', status: 429 };
+      expect(isQwenThrottlingError(error)).toBe(true);
+    });
+
+    it('should detect requests throttling triggered with 429 status', () => {
+      const error = { message: 'requests throttling triggered', status: 429 };
+      expect(isQwenThrottlingError(error)).toBe(true);
+    });
+
+    it('should detect rate limit error with 429 status', () => {
+      const error = { message: 'rate limit exceeded', status: 429 };
+      expect(isQwenThrottlingError(error)).toBe(true);
+    });
+
+    it('should detect too many requests with 429 status', () => {
+      const error = { message: 'too many requests', status: 429 };
+      expect(isQwenThrottlingError(error)).toBe(true);
+    });
+
+    it('should detect throttling in string error', () => {
+      const error = 'throttling';
+      expect(isQwenThrottlingError(error)).toBe(true);
+    });
+
+    it('should detect throttling in structured error with 429', () => {
+      const error = { message: 'requests throttling triggered', status: 429 };
+      expect(isQwenThrottlingError(error)).toBe(true);
+    });
+
+    it('should detect throttling in API error with 429', () => {
+      const error: ApiError = {
+        error: {
+          code: 429,
+          message: 'throttling',
+          status: 'RESOURCE_EXHAUSTED',
+          details: [],
+        },
+      };
+      expect(isQwenThrottlingError(error)).toBe(true);
+    });
+
+    it('should not detect throttling without 429 status in structured error', () => {
+      const error = { message: 'throttling', status: 500 };
+      expect(isQwenThrottlingError(error)).toBe(false);
+    });
+
+    it('should not detect quota exceeded as throttling', () => {
+      const error = { message: 'insufficient_quota', status: 429 };
+      expect(isQwenThrottlingError(error)).toBe(false);
+    });
+
+    it('should not detect unrelated errors as throttling', () => {
+      const error = { message: 'Network error', status: 500 };
+      expect(isQwenThrottlingError(error)).toBe(false);
+    });
+  });
+
+  describe('isProQuotaExceededError', () => {
+    it('should detect Gemini Pro quota exceeded error', () => {
+      const error = new Error(
+        "Quota exceeded for quota metric 'Gemini 2.5 Pro Requests'",
+      );
+      expect(isProQuotaExceededError(error)).toBe(true);
+    });
+
+    it('should detect Gemini preview Pro quota exceeded error', () => {
+      const error = new Error(
+        "Quota exceeded for quota metric 'Gemini 2.5-preview Pro Requests'",
+      );
+      expect(isProQuotaExceededError(error)).toBe(true);
+    });
+
+    it('should not detect non-Pro quota errors', () => {
+      const error = new Error(
+        "Quota exceeded for quota metric 'Gemini 1.5 Flash Requests'",
+      );
+      expect(isProQuotaExceededError(error)).toBe(false);
+    });
+  });
+
+  describe('isGenericQuotaExceededError', () => {
+    it('should detect generic quota exceeded error', () => {
+      const error = new Error('Quota exceeded for quota metric');
+      expect(isGenericQuotaExceededError(error)).toBe(true);
+    });
+
+    it('should not detect non-quota errors', () => {
+      const error = new Error('Network error');
+      expect(isGenericQuotaExceededError(error)).toBe(false);
+    });
+  });
+
+  describe('type guards', () => {
+    describe('isApiError', () => {
+      it('should detect valid API error', () => {
+        const error: ApiError = {
+          error: {
+            code: 429,
+            message: 'test error',
+            status: 'RESOURCE_EXHAUSTED',
+            details: [],
+          },
+        };
+        expect(isApiError(error)).toBe(true);
+      });
+
+      it('should not detect invalid API error', () => {
+        const error = { message: 'test error' };
+        expect(isApiError(error)).toBe(false);
+      });
+    });
+
+    describe('isStructuredError', () => {
+      it('should detect valid structured error', () => {
+        const error = { message: 'test error', status: 429 };
+        expect(isStructuredError(error)).toBe(true);
+      });
+
+      it('should not detect invalid structured error', () => {
+        const error = { code: 429 };
+        expect(isStructuredError(error)).toBe(false);
+      });
+    });
+  });
+});

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

@@ -0,0 +1,167 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { StructuredError } from '../core/turn.js';
+
+export interface ApiError {
+  error: {
+    code: number;
+    message: string;
+    status: string;
+    details: unknown[];
+  };
+}
+
+export function isApiError(error: unknown): error is ApiError {
+  return (
+    typeof error === 'object' &&
+    error !== null &&
+    'error' in error &&
+    typeof (error as ApiError).error === 'object' &&
+    'message' in (error as ApiError).error
+  );
+}
+
+export function isStructuredError(error: unknown): error is StructuredError {
+  return (
+    typeof error === 'object' &&
+    error !== null &&
+    'message' in error &&
+    typeof (error as StructuredError).message === 'string'
+  );
+}
+
+export function isProQuotaExceededError(error: unknown): boolean {
+  // Check for Pro quota exceeded errors by looking for the specific pattern
+  // This will match patterns like:
+  // - "Quota exceeded for quota metric 'Gemini 2.5 Pro Requests'"
+  // - "Quota exceeded for quota metric 'Gemini 2.5-preview Pro Requests'"
+  // We use string methods instead of regex to avoid ReDoS vulnerabilities
+
+  const checkMessage = (message: string): boolean =>
+    message.includes("Quota exceeded for quota metric 'Gemini") &&
+    message.includes("Pro Requests'");
+
+  if (typeof error === 'string') {
+    return checkMessage(error);
+  }
+
+  if (isStructuredError(error)) {
+    return checkMessage(error.message);
+  }
+
+  if (isApiError(error)) {
+    return checkMessage(error.error.message);
+  }
+
+  // Check if it's a Gaxios error with response data
+  if (error && typeof error === 'object' && 'response' in error) {
+    const gaxiosError = error as {
+      response?: {
+        data?: unknown;
+      };
+    };
+    if (gaxiosError.response && gaxiosError.response.data) {
+      if (typeof gaxiosError.response.data === 'string') {
+        return checkMessage(gaxiosError.response.data);
+      }
+      if (
+        typeof gaxiosError.response.data === 'object' &&
+        gaxiosError.response.data !== null &&
+        'error' in gaxiosError.response.data
+      ) {
+        const errorData = gaxiosError.response.data as {
+          error?: { message?: string };
+        };
+        return checkMessage(errorData.error?.message || '');
+      }
+    }
+  }
+  return false;
+}
+
+export function isGenericQuotaExceededError(error: unknown): boolean {
+  if (typeof error === 'string') {
+    return error.includes('Quota exceeded for quota metric');
+  }
+
+  if (isStructuredError(error)) {
+    return error.message.includes('Quota exceeded for quota metric');
+  }
+
+  if (isApiError(error)) {
+    return error.error.message.includes('Quota exceeded for quota metric');
+  }
+
+  return false;
+}
+
+export function isQwenQuotaExceededError(error: unknown): boolean {
+  // Check for Qwen insufficient quota errors (should not retry)
+  const checkMessage = (message: string): boolean => {
+    const lowerMessage = message.toLowerCase();
+    return (
+      lowerMessage.includes('insufficient_quota') ||
+      lowerMessage.includes('free allocated quota exceeded') ||
+      (lowerMessage.includes('quota') && lowerMessage.includes('exceeded'))
+    );
+  };
+
+  if (typeof error === 'string') {
+    return checkMessage(error);
+  }
+
+  if (isStructuredError(error)) {
+    return checkMessage(error.message);
+  }
+
+  if (isApiError(error)) {
+    return checkMessage(error.error.message);
+  }
+
+  return false;
+}
+
+export function isQwenThrottlingError(error: unknown): boolean {
+  // Check for Qwen throttling errors (should retry)
+  const checkMessage = (message: string): boolean => {
+    const lowerMessage = message.toLowerCase();
+    return (
+      lowerMessage.includes('throttling') ||
+      lowerMessage.includes('requests throttling triggered') ||
+      lowerMessage.includes('rate limit') ||
+      lowerMessage.includes('too many requests')
+    );
+  };
+
+  // Check status code
+  const getStatusCode = (error: unknown): number | undefined => {
+    if (error && typeof error === 'object') {
+      const errorObj = error as { status?: number; code?: number };
+      return errorObj.status || errorObj.code;
+    }
+    return undefined;
+  };
+
+  const statusCode = getStatusCode(error);
+
+  if (typeof error === 'string') {
+    return (
+      (statusCode === 429 && checkMessage(error)) ||
+      error.includes('throttling')
+    );
+  }
+
+  if (isStructuredError(error)) {
+    return statusCode === 429 && checkMessage(error.message);
+  }
+
+  if (isApiError(error)) {
+    return error.error.code === 429 && checkMessage(error.error.message);
+  }
+
+  return false;
+}

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

@@ -0,0 +1,572 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { retryWithBackoff, HttpError } from './retry.js';
+import { setSimulate429 } from './testUtils.js';
+import { AuthType } from '../core/contentGenerator.js';
+
+// Helper to create a mock function that fails a certain number of times
+const createFailingFunction = (
+  failures: number,
+  successValue: string = 'success',
+) => {
+  let attempts = 0;
+  return vi.fn(async () => {
+    attempts++;
+    if (attempts <= failures) {
+      // Simulate a retryable error
+      const error: HttpError = new Error(`Simulated error attempt ${attempts}`);
+      error.status = 500; // Simulate a server error
+      throw error;
+    }
+    return successValue;
+  });
+};
+
+// Custom error for testing non-retryable conditions
+class NonRetryableError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = 'NonRetryableError';
+  }
+}
+
+describe('retryWithBackoff', () => {
+  beforeEach(() => {
+    vi.useFakeTimers();
+    // Disable 429 simulation for tests
+    setSimulate429(false);
+    // Suppress unhandled promise rejection warnings for tests that expect errors
+    console.warn = vi.fn();
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+    vi.useRealTimers();
+  });
+
+  it('should return the result on the first attempt if successful', async () => {
+    const mockFn = createFailingFunction(0);
+    const result = await retryWithBackoff(mockFn);
+    expect(result).toBe('success');
+    expect(mockFn).toHaveBeenCalledTimes(1);
+  });
+
+  it('should retry and succeed if failures are within maxAttempts', async () => {
+    const mockFn = createFailingFunction(2);
+    const promise = retryWithBackoff(mockFn, {
+      maxAttempts: 3,
+      initialDelayMs: 10,
+    });
+
+    await vi.runAllTimersAsync(); // Ensure all delays and retries complete
+
+    const result = await promise;
+    expect(result).toBe('success');
+    expect(mockFn).toHaveBeenCalledTimes(3);
+  });
+
+  it('should throw an error if all attempts fail', async () => {
+    const mockFn = createFailingFunction(3);
+
+    // 1. Start the retryable operation, which returns a promise.
+    const promise = retryWithBackoff(mockFn, {
+      maxAttempts: 3,
+      initialDelayMs: 10,
+    });
+
+    // 2. IMPORTANT: Attach the rejection expectation to the promise *immediately*.
+    //    This ensures a 'catch' handler is present before the promise can reject.
+    //    The result is a new promise that resolves when the assertion is met.
+    const assertionPromise = expect(promise).rejects.toThrow(
+      'Simulated error attempt 3',
+    );
+
+    // 3. Now, advance the timers. This will trigger the retries and the
+    //    eventual rejection. The handler attached in step 2 will catch it.
+    await vi.runAllTimersAsync();
+
+    // 4. Await the assertion promise itself to ensure the test was successful.
+    await assertionPromise;
+
+    // 5. Finally, assert the number of calls.
+    expect(mockFn).toHaveBeenCalledTimes(3);
+  });
+
+  it('should not retry if shouldRetry returns false', async () => {
+    const mockFn = vi.fn(async () => {
+      throw new NonRetryableError('Non-retryable error');
+    });
+    const shouldRetry = (error: Error) => !(error instanceof NonRetryableError);
+
+    const promise = retryWithBackoff(mockFn, {
+      shouldRetry,
+      initialDelayMs: 10,
+    });
+
+    await expect(promise).rejects.toThrow('Non-retryable error');
+    expect(mockFn).toHaveBeenCalledTimes(1);
+  });
+
+  it('should use default shouldRetry if not provided, retrying on 429', async () => {
+    const mockFn = vi.fn(async () => {
+      const error = new Error('Too Many Requests') as any;
+      error.status = 429;
+      throw error;
+    });
+
+    const promise = retryWithBackoff(mockFn, {
+      maxAttempts: 2,
+      initialDelayMs: 10,
+    });
+
+    // Attach the rejection expectation *before* running timers
+    const assertionPromise =
+      expect(promise).rejects.toThrow('Too Many Requests');
+
+    // Run timers to trigger retries and eventual rejection
+    await vi.runAllTimersAsync();
+
+    // Await the assertion
+    await assertionPromise;
+
+    expect(mockFn).toHaveBeenCalledTimes(2);
+  });
+
+  it('should use default shouldRetry if not provided, not retrying on 400', async () => {
+    const mockFn = vi.fn(async () => {
+      const error = new Error('Bad Request') as any;
+      error.status = 400;
+      throw error;
+    });
+
+    const promise = retryWithBackoff(mockFn, {
+      maxAttempts: 2,
+      initialDelayMs: 10,
+    });
+    await expect(promise).rejects.toThrow('Bad Request');
+    expect(mockFn).toHaveBeenCalledTimes(1);
+  });
+
+  it('should respect maxDelayMs', async () => {
+    const mockFn = createFailingFunction(3);
+    const setTimeoutSpy = vi.spyOn(global, 'setTimeout');
+
+    const promise = retryWithBackoff(mockFn, {
+      maxAttempts: 4,
+      initialDelayMs: 100,
+      maxDelayMs: 250, // Max delay is less than 100 * 2 * 2 = 400
+    });
+
+    await vi.advanceTimersByTimeAsync(1000); // Advance well past all delays
+    await promise;
+
+    const delays = setTimeoutSpy.mock.calls.map((call) => call[1] as number);
+
+    // Delays should be around initial, initial*2, maxDelay (due to cap)
+    // Jitter makes exact assertion hard, so we check ranges / caps
+    expect(delays.length).toBe(3);
+    expect(delays[0]).toBeGreaterThanOrEqual(100 * 0.7);
+    expect(delays[0]).toBeLessThanOrEqual(100 * 1.3);
+    expect(delays[1]).toBeGreaterThanOrEqual(200 * 0.7);
+    expect(delays[1]).toBeLessThanOrEqual(200 * 1.3);
+    // The third delay should be capped by maxDelayMs (250ms), accounting for jitter
+    expect(delays[2]).toBeGreaterThanOrEqual(250 * 0.7);
+    expect(delays[2]).toBeLessThanOrEqual(250 * 1.3);
+  });
+
+  it('should handle jitter correctly, ensuring varied delays', async () => {
+    let mockFn = createFailingFunction(5);
+    const setTimeoutSpy = vi.spyOn(global, 'setTimeout');
+
+    // Run retryWithBackoff multiple times to observe jitter
+    const runRetry = () =>
+      retryWithBackoff(mockFn, {
+        maxAttempts: 2, // Only one retry, so one delay
+        initialDelayMs: 100,
+        maxDelayMs: 1000,
+      });
+
+    // We expect rejections as mockFn fails 5 times
+    const promise1 = runRetry();
+    // Attach the rejection expectation *before* running timers
+    const assertionPromise1 = expect(promise1).rejects.toThrow();
+    await vi.runAllTimersAsync(); // Advance for the delay in the first runRetry
+    await assertionPromise1;
+
+    const firstDelaySet = setTimeoutSpy.mock.calls.map(
+      (call) => call[1] as number,
+    );
+    setTimeoutSpy.mockClear(); // Clear calls for the next run
+
+    // Reset mockFn to reset its internal attempt counter for the next run
+    mockFn = createFailingFunction(5); // Re-initialize with 5 failures
+
+    const promise2 = runRetry();
+    // Attach the rejection expectation *before* running timers
+    const assertionPromise2 = expect(promise2).rejects.toThrow();
+    await vi.runAllTimersAsync(); // Advance for the delay in the second runRetry
+    await assertionPromise2;
+
+    const secondDelaySet = setTimeoutSpy.mock.calls.map(
+      (call) => call[1] as number,
+    );
+
+    // Check that the delays are not exactly the same due to jitter
+    // This is a probabilistic test, but with +/-30% jitter, it's highly likely they differ.
+    if (firstDelaySet.length > 0 && secondDelaySet.length > 0) {
+      // Check the first delay of each set
+      expect(firstDelaySet[0]).not.toBe(secondDelaySet[0]);
+    } else {
+      // If somehow no delays were captured (e.g. test setup issue), fail explicitly
+      throw new Error('Delays were not captured for jitter test');
+    }
+
+    // Ensure delays are within the expected jitter range [70, 130] for initialDelayMs = 100
+    [...firstDelaySet, ...secondDelaySet].forEach((d) => {
+      expect(d).toBeGreaterThanOrEqual(100 * 0.7);
+      expect(d).toBeLessThanOrEqual(100 * 1.3);
+    });
+  });
+
+  describe('Flash model fallback for OAuth users', () => {
+    it('should trigger fallback for OAuth personal users after persistent 429 errors', async () => {
+      const fallbackCallback = vi.fn().mockResolvedValue('gemini-2.5-flash');
+
+      let fallbackOccurred = false;
+      const mockFn = vi.fn().mockImplementation(async () => {
+        if (!fallbackOccurred) {
+          const error: HttpError = new Error('Rate limit exceeded');
+          error.status = 429;
+          throw error;
+        }
+        return 'success';
+      });
+
+      const promise = retryWithBackoff(mockFn, {
+        maxAttempts: 3,
+        initialDelayMs: 100,
+        onPersistent429: async (authType?: string) => {
+          fallbackOccurred = true;
+          return await fallbackCallback(authType);
+        },
+        authType: 'oauth-personal',
+      });
+
+      // Advance all timers to complete retries
+      await vi.runAllTimersAsync();
+
+      // Should succeed after fallback
+      await expect(promise).resolves.toBe('success');
+
+      // Verify callback was called with correct auth type
+      expect(fallbackCallback).toHaveBeenCalledWith('oauth-personal');
+
+      // Should retry again after fallback
+      expect(mockFn).toHaveBeenCalledTimes(3); // 2 initial attempts + 1 after fallback
+    });
+
+    it('should NOT trigger fallback for API key users', async () => {
+      const fallbackCallback = vi.fn();
+
+      const mockFn = vi.fn(async () => {
+        const error: HttpError = new Error('Rate limit exceeded');
+        error.status = 429;
+        throw error;
+      });
+
+      const promise = retryWithBackoff(mockFn, {
+        maxAttempts: 3,
+        initialDelayMs: 100,
+        onPersistent429: fallbackCallback,
+        authType: 'gemini-api-key',
+      });
+
+      // Handle the promise properly to avoid unhandled rejections
+      const resultPromise = promise.catch((error) => error);
+      await vi.runAllTimersAsync();
+      const result = await resultPromise;
+
+      // Should fail after all retries without fallback
+      expect(result).toBeInstanceOf(Error);
+      expect(result.message).toBe('Rate limit exceeded');
+
+      // Callback should not be called for API key users
+      expect(fallbackCallback).not.toHaveBeenCalled();
+    });
+
+    it('should reset attempt counter and continue after successful fallback', async () => {
+      let fallbackCalled = false;
+      const fallbackCallback = vi.fn().mockImplementation(async () => {
+        fallbackCalled = true;
+        return 'gemini-2.5-flash';
+      });
+
+      const mockFn = vi.fn().mockImplementation(async () => {
+        if (!fallbackCalled) {
+          const error: HttpError = new Error('Rate limit exceeded');
+          error.status = 429;
+          throw error;
+        }
+        return 'success';
+      });
+
+      const promise = retryWithBackoff(mockFn, {
+        maxAttempts: 3,
+        initialDelayMs: 100,
+        onPersistent429: fallbackCallback,
+        authType: 'oauth-personal',
+      });
+
+      await vi.runAllTimersAsync();
+
+      await expect(promise).resolves.toBe('success');
+      expect(fallbackCallback).toHaveBeenCalledOnce();
+    });
+
+    it('should continue with original error if fallback is rejected', async () => {
+      const fallbackCallback = vi.fn().mockResolvedValue(null); // User rejected fallback
+
+      const mockFn = vi.fn(async () => {
+        const error: HttpError = new Error('Rate limit exceeded');
+        error.status = 429;
+        throw error;
+      });
+
+      const promise = retryWithBackoff(mockFn, {
+        maxAttempts: 3,
+        initialDelayMs: 100,
+        onPersistent429: fallbackCallback,
+        authType: 'oauth-personal',
+      });
+
+      // Handle the promise properly to avoid unhandled rejections
+      const resultPromise = promise.catch((error) => error);
+      await vi.runAllTimersAsync();
+      const result = await resultPromise;
+
+      // Should fail with original error when fallback is rejected
+      expect(result).toBeInstanceOf(Error);
+      expect(result.message).toBe('Rate limit exceeded');
+      expect(fallbackCallback).toHaveBeenCalledWith(
+        'oauth-personal',
+        expect.any(Error),
+      );
+    });
+
+    it('should handle mixed error types (only count consecutive 429s)', async () => {
+      const fallbackCallback = vi.fn().mockResolvedValue('gemini-2.5-flash');
+      let attempts = 0;
+      let fallbackOccurred = false;
+
+      const mockFn = vi.fn().mockImplementation(async () => {
+        attempts++;
+        if (fallbackOccurred) {
+          return 'success';
+        }
+        if (attempts === 1) {
+          // First attempt: 500 error (resets consecutive count)
+          const error: HttpError = new Error('Server error');
+          error.status = 500;
+          throw error;
+        } else {
+          // Remaining attempts: 429 errors
+          const error: HttpError = new Error('Rate limit exceeded');
+          error.status = 429;
+          throw error;
+        }
+      });
+
+      const promise = retryWithBackoff(mockFn, {
+        maxAttempts: 5,
+        initialDelayMs: 100,
+        onPersistent429: async (authType?: string) => {
+          fallbackOccurred = true;
+          return await fallbackCallback(authType);
+        },
+        authType: 'oauth-personal',
+      });
+
+      await vi.runAllTimersAsync();
+
+      await expect(promise).resolves.toBe('success');
+
+      // Should trigger fallback after 2 consecutive 429s (attempts 2-3)
+      expect(fallbackCallback).toHaveBeenCalledWith('oauth-personal');
+    });
+  });
+
+  describe('Qwen OAuth 429 error handling', () => {
+    it('should retry for Qwen OAuth 429 errors that are throttling-related', async () => {
+      const errorWith429: HttpError = new Error('Rate limit exceeded');
+      errorWith429.status = 429;
+
+      const fn = vi
+        .fn()
+        .mockRejectedValueOnce(errorWith429)
+        .mockResolvedValue('success');
+
+      const promise = retryWithBackoff(fn, {
+        maxAttempts: 5,
+        initialDelayMs: 100,
+        maxDelayMs: 1000,
+        shouldRetry: () => true,
+        authType: AuthType.QWEN_OAUTH,
+      });
+
+      // Fast-forward time for delays
+      await vi.runAllTimersAsync();
+
+      await expect(promise).resolves.toBe('success');
+
+      // Should be called twice (1 failure + 1 success)
+      expect(fn).toHaveBeenCalledTimes(2);
+    });
+
+    it('should throw immediately for Qwen OAuth with insufficient_quota message', async () => {
+      const errorWithInsufficientQuota = new Error('insufficient_quota');
+
+      const fn = vi.fn().mockRejectedValue(errorWithInsufficientQuota);
+
+      const promise = retryWithBackoff(fn, {
+        maxAttempts: 5,
+        initialDelayMs: 1000,
+        maxDelayMs: 5000,
+        shouldRetry: () => true,
+        authType: AuthType.QWEN_OAUTH,
+      });
+
+      await expect(promise).rejects.toThrow(/Qwen API quota exceeded/);
+
+      // Should be called only once (no retries)
+      expect(fn).toHaveBeenCalledTimes(1);
+    });
+
+    it('should throw immediately for Qwen OAuth with free allocated quota exceeded message', async () => {
+      const errorWithQuotaExceeded = new Error(
+        'Free allocated quota exceeded.',
+      );
+
+      const fn = vi.fn().mockRejectedValue(errorWithQuotaExceeded);
+
+      const promise = retryWithBackoff(fn, {
+        maxAttempts: 5,
+        initialDelayMs: 1000,
+        maxDelayMs: 5000,
+        shouldRetry: () => true,
+        authType: AuthType.QWEN_OAUTH,
+      });
+
+      await expect(promise).rejects.toThrow(/Qwen API quota exceeded/);
+
+      // Should be called only once (no retries)
+      expect(fn).toHaveBeenCalledTimes(1);
+    });
+
+    it('should retry for Qwen OAuth with throttling message', async () => {
+      const throttlingError: HttpError = new Error(
+        'requests throttling triggered',
+      );
+      throttlingError.status = 429;
+
+      const fn = vi
+        .fn()
+        .mockRejectedValueOnce(throttlingError)
+        .mockRejectedValueOnce(throttlingError)
+        .mockResolvedValue('success');
+
+      const promise = retryWithBackoff(fn, {
+        maxAttempts: 5,
+        initialDelayMs: 100,
+        maxDelayMs: 1000,
+        shouldRetry: () => true,
+        authType: AuthType.QWEN_OAUTH,
+      });
+
+      // Fast-forward time for delays
+      await vi.runAllTimersAsync();
+
+      await expect(promise).resolves.toBe('success');
+
+      // Should be called 3 times (2 failures + 1 success)
+      expect(fn).toHaveBeenCalledTimes(3);
+    });
+
+    it('should retry for Qwen OAuth with throttling error', async () => {
+      const throttlingError: HttpError = new Error('throttling');
+      throttlingError.status = 429;
+
+      const fn = vi
+        .fn()
+        .mockRejectedValueOnce(throttlingError)
+        .mockResolvedValue('success');
+
+      const promise = retryWithBackoff(fn, {
+        maxAttempts: 5,
+        initialDelayMs: 100,
+        maxDelayMs: 1000,
+        shouldRetry: () => true,
+        authType: AuthType.QWEN_OAUTH,
+      });
+
+      // Fast-forward time for delays
+      await vi.runAllTimersAsync();
+
+      await expect(promise).resolves.toBe('success');
+
+      // Should be called 2 times (1 failure + 1 success)
+      expect(fn).toHaveBeenCalledTimes(2);
+    });
+
+    it('should throw immediately for Qwen OAuth with quota message', async () => {
+      const errorWithQuota = new Error('quota exceeded');
+
+      const fn = vi.fn().mockRejectedValue(errorWithQuota);
+
+      const promise = retryWithBackoff(fn, {
+        maxAttempts: 5,
+        initialDelayMs: 1000,
+        maxDelayMs: 5000,
+        shouldRetry: () => true,
+        authType: AuthType.QWEN_OAUTH,
+      });
+
+      await expect(promise).rejects.toThrow(/Qwen API quota exceeded/);
+
+      // Should be called only once (no retries)
+      expect(fn).toHaveBeenCalledTimes(1);
+    });
+
+    it('should retry normal errors for Qwen OAuth (not quota-related)', async () => {
+      const normalError: HttpError = new Error('Network error');
+      normalError.status = 500;
+
+      const fn = createFailingFunction(2, 'success');
+      // Replace the default 500 error with our normal error
+      fn.mockRejectedValueOnce(normalError)
+        .mockRejectedValueOnce(normalError)
+        .mockResolvedValue('success');
+
+      const promise = retryWithBackoff(fn, {
+        maxAttempts: 5,
+        initialDelayMs: 100,
+        maxDelayMs: 1000,
+        shouldRetry: () => true,
+        authType: AuthType.QWEN_OAUTH,
+      });
+
+      // Fast-forward time for delays
+      await vi.runAllTimersAsync();
+
+      await expect(promise).resolves.toBe('success');
+
+      // Should be called 3 times (2 failures + 1 success)
+      expect(fn).toHaveBeenCalledTimes(3);
+    });
+  });
+});

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

@@ -0,0 +1,355 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { AuthType } from '../core/contentGenerator.js';
+import {
+  isProQuotaExceededError,
+  isGenericQuotaExceededError,
+  isQwenQuotaExceededError,
+  isQwenThrottlingError,
+} from './quotaErrorDetection.js';
+
+export interface HttpError extends Error {
+  status?: number;
+}
+
+export interface RetryOptions {
+  maxAttempts: number;
+  initialDelayMs: number;
+  maxDelayMs: number;
+  shouldRetry: (error: Error) => boolean;
+  onPersistent429?: (
+    authType?: string,
+    error?: unknown,
+  ) => Promise<string | boolean | null>;
+  authType?: string;
+}
+
+const DEFAULT_RETRY_OPTIONS: RetryOptions = {
+  maxAttempts: 5,
+  initialDelayMs: 5000,
+  maxDelayMs: 30000, // 30 seconds
+  shouldRetry: defaultShouldRetry,
+};
+
+/**
+ * Default predicate function to determine if a retry should be attempted.
+ * Retries on 429 (Too Many Requests) and 5xx server errors.
+ * @param error The error object.
+ * @returns True if the error is a transient error, false otherwise.
+ */
+function defaultShouldRetry(error: Error | unknown): boolean {
+  // Check for common transient error status codes either in message or a status property
+  if (error && typeof (error as { status?: number }).status === 'number') {
+    const status = (error as { status: number }).status;
+    if (status === 429 || (status >= 500 && status < 600)) {
+      return true;
+    }
+  }
+  if (error instanceof Error && error.message) {
+    if (error.message.includes('429')) return true;
+    if (error.message.match(/5\d{2}/)) return true;
+  }
+  return false;
+}
+
+/**
+ * Delays execution for a specified number of milliseconds.
+ * @param ms The number of milliseconds to delay.
+ * @returns A promise that resolves after the delay.
+ */
+function delay(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+/**
+ * Retries a function with exponential backoff and jitter.
+ * @param fn The asynchronous function to retry.
+ * @param options Optional retry configuration.
+ * @returns A promise that resolves with the result of the function if successful.
+ * @throws The last error encountered if all attempts fail.
+ */
+export async function retryWithBackoff<T>(
+  fn: () => Promise<T>,
+  options?: Partial<RetryOptions>,
+): Promise<T> {
+  const {
+    maxAttempts,
+    initialDelayMs,
+    maxDelayMs,
+    onPersistent429,
+    authType,
+    shouldRetry,
+  } = {
+    ...DEFAULT_RETRY_OPTIONS,
+    ...options,
+  };
+
+  let attempt = 0;
+  let currentDelay = initialDelayMs;
+  let consecutive429Count = 0;
+
+  while (attempt < maxAttempts) {
+    attempt++;
+    try {
+      return await fn();
+    } catch (error) {
+      const errorStatus = getErrorStatus(error);
+
+      // Check for Pro quota exceeded error first - immediate fallback for OAuth users
+      if (
+        errorStatus === 429 &&
+        authType === AuthType.LOGIN_WITH_GOOGLE &&
+        isProQuotaExceededError(error) &&
+        onPersistent429
+      ) {
+        try {
+          const fallbackModel = await onPersistent429(authType, error);
+          if (fallbackModel !== false && fallbackModel !== null) {
+            // Reset attempt counter and try with new model
+            attempt = 0;
+            consecutive429Count = 0;
+            currentDelay = initialDelayMs;
+            // With the model updated, we continue to the next attempt
+            continue;
+          } else {
+            // Fallback handler returned null/false, meaning don't continue - stop retry process
+            throw error;
+          }
+        } catch (fallbackError) {
+          // If fallback fails, continue with original error
+          console.warn('Fallback to Flash model failed:', fallbackError);
+        }
+      }
+
+      // Check for generic quota exceeded error (but not Pro, which was handled above) - immediate fallback for OAuth users
+      if (
+        errorStatus === 429 &&
+        authType === AuthType.LOGIN_WITH_GOOGLE &&
+        !isProQuotaExceededError(error) &&
+        isGenericQuotaExceededError(error) &&
+        onPersistent429
+      ) {
+        try {
+          const fallbackModel = await onPersistent429(authType, error);
+          if (fallbackModel !== false && fallbackModel !== null) {
+            // Reset attempt counter and try with new model
+            attempt = 0;
+            consecutive429Count = 0;
+            currentDelay = initialDelayMs;
+            // With the model updated, we continue to the next attempt
+            continue;
+          } else {
+            // Fallback handler returned null/false, meaning don't continue - stop retry process
+            throw error;
+          }
+        } catch (fallbackError) {
+          // If fallback fails, continue with original error
+          console.warn('Fallback to Flash model failed:', fallbackError);
+        }
+      }
+
+      // Check for Qwen OAuth quota exceeded error - throw immediately without retry
+      if (authType === AuthType.QWEN_OAUTH && isQwenQuotaExceededError(error)) {
+        throw new Error(
+          `Qwen API quota exceeded: Your Qwen API quota has been exhausted. Please wait for your quota to reset.`,
+        );
+      }
+
+      // Track consecutive 429 errors, but handle Qwen throttling differently
+      if (errorStatus === 429) {
+        // For Qwen throttling errors, we still want to track them for exponential backoff
+        // but not for quota fallback logic (since Qwen doesn't have model fallback)
+        if (authType === AuthType.QWEN_OAUTH && isQwenThrottlingError(error)) {
+          // Keep track of 429s but reset the consecutive count to avoid fallback logic
+          consecutive429Count = 0;
+        } else {
+          consecutive429Count++;
+        }
+      } else {
+        consecutive429Count = 0;
+      }
+
+      // If we have persistent 429s and a fallback callback for OAuth
+      if (
+        consecutive429Count >= 2 &&
+        onPersistent429 &&
+        authType === AuthType.LOGIN_WITH_GOOGLE
+      ) {
+        try {
+          const fallbackModel = await onPersistent429(authType, error);
+          if (fallbackModel !== false && fallbackModel !== null) {
+            // Reset attempt counter and try with new model
+            attempt = 0;
+            consecutive429Count = 0;
+            currentDelay = initialDelayMs;
+            // With the model updated, we continue to the next attempt
+            continue;
+          } else {
+            // Fallback handler returned null/false, meaning don't continue - stop retry process
+            throw error;
+          }
+        } catch (fallbackError) {
+          // If fallback fails, continue with original error
+          console.warn('Fallback to Flash model failed:', fallbackError);
+        }
+      }
+
+      // Check if we've exhausted retries or shouldn't retry
+      if (attempt >= maxAttempts || !shouldRetry(error as Error)) {
+        throw error;
+      }
+
+      const { delayDurationMs, errorStatus: delayErrorStatus } =
+        getDelayDurationAndStatus(error);
+
+      if (delayDurationMs > 0) {
+        // Respect Retry-After header if present and parsed
+        console.warn(
+          `Attempt ${attempt} failed with status ${delayErrorStatus ?? 'unknown'}. Retrying after explicit delay of ${delayDurationMs}ms...`,
+          error,
+        );
+        await delay(delayDurationMs);
+        // Reset currentDelay for next potential non-429 error, or if Retry-After is not present next time
+        currentDelay = initialDelayMs;
+      } else {
+        // Fall back to exponential backoff with jitter
+        logRetryAttempt(attempt, error, errorStatus);
+        // Add jitter: +/- 30% of currentDelay
+        const jitter = currentDelay * 0.3 * (Math.random() * 2 - 1);
+        const delayWithJitter = Math.max(0, currentDelay + jitter);
+        await delay(delayWithJitter);
+        currentDelay = Math.min(maxDelayMs, currentDelay * 2);
+      }
+    }
+  }
+  // This line should theoretically be unreachable due to the throw in the catch block.
+  // Added for type safety and to satisfy the compiler that a promise is always returned.
+  throw new Error('Retry attempts exhausted');
+}
+
+/**
+ * Extracts the HTTP status code from an error object.
+ * @param error The error object.
+ * @returns The HTTP status code, or undefined if not found.
+ */
+export function getErrorStatus(error: unknown): number | undefined {
+  if (typeof error === 'object' && error !== null) {
+    if ('status' in error && typeof error.status === 'number') {
+      return error.status;
+    }
+    // Check for error.response.status (common in axios errors)
+    if (
+      'response' in error &&
+      typeof (error as { response?: unknown }).response === 'object' &&
+      (error as { response?: unknown }).response !== null
+    ) {
+      const response = (
+        error as { response: { status?: unknown; headers?: unknown } }
+      ).response;
+      if ('status' in response && typeof response.status === 'number') {
+        return response.status;
+      }
+    }
+  }
+  return undefined;
+}
+
+/**
+ * Extracts the Retry-After delay from an error object's headers.
+ * @param error The error object.
+ * @returns The delay in milliseconds, or 0 if not found or invalid.
+ */
+function getRetryAfterDelayMs(error: unknown): number {
+  if (typeof error === 'object' && error !== null) {
+    // Check for error.response.headers (common in axios errors)
+    if (
+      'response' in error &&
+      typeof (error as { response?: unknown }).response === 'object' &&
+      (error as { response?: unknown }).response !== null
+    ) {
+      const response = (error as { response: { headers?: unknown } }).response;
+      if (
+        'headers' in response &&
+        typeof response.headers === 'object' &&
+        response.headers !== null
+      ) {
+        const headers = response.headers as { 'retry-after'?: unknown };
+        const retryAfterHeader = headers['retry-after'];
+        if (typeof retryAfterHeader === 'string') {
+          const retryAfterSeconds = parseInt(retryAfterHeader, 10);
+          if (!isNaN(retryAfterSeconds)) {
+            return retryAfterSeconds * 1000;
+          }
+          // It might be an HTTP date
+          const retryAfterDate = new Date(retryAfterHeader);
+          if (!isNaN(retryAfterDate.getTime())) {
+            return Math.max(0, retryAfterDate.getTime() - Date.now());
+          }
+        }
+      }
+    }
+  }
+  return 0;
+}
+
+/**
+ * Determines the delay duration based on the error, prioritizing Retry-After header.
+ * @param error The error object.
+ * @returns An object containing the delay duration in milliseconds and the error status.
+ */
+function getDelayDurationAndStatus(error: unknown): {
+  delayDurationMs: number;
+  errorStatus: number | undefined;
+} {
+  const errorStatus = getErrorStatus(error);
+  let delayDurationMs = 0;
+
+  if (errorStatus === 429) {
+    delayDurationMs = getRetryAfterDelayMs(error);
+  }
+  return { delayDurationMs, errorStatus };
+}
+
+/**
+ * Logs a message for a retry attempt when using exponential backoff.
+ * @param attempt The current attempt number.
+ * @param error The error that caused the retry.
+ * @param errorStatus The HTTP status code of the error, if available.
+ */
+function logRetryAttempt(
+  attempt: number,
+  error: unknown,
+  errorStatus?: number,
+): void {
+  let message = `Attempt ${attempt} failed. Retrying with backoff...`;
+  if (errorStatus) {
+    message = `Attempt ${attempt} failed with status ${errorStatus}. Retrying with backoff...`;
+  }
+
+  if (errorStatus === 429) {
+    console.warn(message, error);
+  } else if (errorStatus && errorStatus >= 500 && errorStatus < 600) {
+    console.error(message, error);
+  } else if (error instanceof Error) {
+    // Fallback for errors that might not have a status but have a message
+    if (error.message.includes('429')) {
+      console.warn(
+        `Attempt ${attempt} failed with 429 error (no Retry-After header). Retrying with backoff...`,
+        error,
+      );
+    } else if (error.message.match(/5\d{2}/)) {
+      console.error(
+        `Attempt ${attempt} failed with 5xx error. Retrying with backoff...`,
+        error,
+      );
+    } else {
+      console.warn(message, error); // Default to warn for other errors
+    }
+  } else {
+    console.warn(message, error); // Default to warn if error type is unknown
+  }
+}

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

@@ -0,0 +1,149 @@
+/**
+ * @license
+ * Copyright 2025 Qwen
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { safeJsonParse } from './safeJsonParse.js';
+
+describe('safeJsonParse', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  describe('valid JSON parsing', () => {
+    it('should parse valid JSON correctly', () => {
+      const validJson = '{"name": "test", "value": 123}';
+      const result = safeJsonParse(validJson);
+
+      expect(result).toEqual({ name: 'test', value: 123 });
+    });
+
+    it('should parse valid JSON arrays', () => {
+      const validArray = '["item1", "item2", "item3"]';
+      const result = safeJsonParse(validArray);
+
+      expect(result).toEqual(['item1', 'item2', 'item3']);
+    });
+
+    it('should parse valid JSON with nested objects', () => {
+      const validNested =
+        '{"config": {"paths": ["testlogs/*.py"], "options": {"recursive": true}}}';
+      const result = safeJsonParse(validNested);
+
+      expect(result).toEqual({
+        config: {
+          paths: ['testlogs/*.py'],
+          options: { recursive: true },
+        },
+      });
+    });
+  });
+
+  describe('malformed JSON with jsonrepair fallback', () => {
+    it('should handle malformed JSON with single quotes', () => {
+      const malformedJson = "{'name': 'test', 'value': 123}";
+      const result = safeJsonParse(malformedJson);
+
+      expect(result).toEqual({ name: 'test', value: 123 });
+    });
+
+    it('should handle malformed JSON with unquoted keys', () => {
+      const malformedJson = '{name: "test", value: 123}';
+      const result = safeJsonParse(malformedJson);
+
+      expect(result).toEqual({ name: 'test', value: 123 });
+    });
+
+    it('should handle malformed JSON with trailing commas', () => {
+      const malformedJson = '{"name": "test", "value": 123,}';
+      const result = safeJsonParse(malformedJson);
+
+      expect(result).toEqual({ name: 'test', value: 123 });
+    });
+
+    it('should handle malformed JSON with comments', () => {
+      const malformedJson = '{"name": "test", // comment\n "value": 123}';
+      const result = safeJsonParse(malformedJson);
+
+      expect(result).toEqual({ name: 'test', value: 123 });
+    });
+  });
+
+  describe('fallback behavior', () => {
+    it('should return fallback value for empty string', () => {
+      const emptyString = '';
+      const fallback = { default: 'value' };
+
+      const result = safeJsonParse(emptyString, fallback);
+
+      expect(result).toEqual(fallback);
+    });
+
+    it('should return fallback value for null input', () => {
+      const nullInput = null as unknown as string;
+      const fallback = { default: 'value' };
+
+      const result = safeJsonParse(nullInput, fallback);
+
+      expect(result).toEqual(fallback);
+    });
+
+    it('should return fallback value for undefined input', () => {
+      const undefinedInput = undefined as unknown as string;
+      const fallback = { default: 'value' };
+
+      const result = safeJsonParse(undefinedInput, fallback);
+
+      expect(result).toEqual(fallback);
+    });
+
+    it('should return empty object as default fallback', () => {
+      const invalidJson = 'invalid json';
+
+      const result = safeJsonParse(invalidJson);
+
+      // jsonrepair returns the original string for completely invalid JSON
+      expect(result).toEqual('invalid json');
+    });
+
+    it('should return custom fallback when parsing fails', () => {
+      const invalidJson = 'invalid json';
+      const customFallback = { error: 'parsing failed', data: null };
+
+      const result = safeJsonParse(invalidJson, customFallback);
+
+      // jsonrepair returns the original string for completely invalid JSON
+      expect(result).toEqual('invalid json');
+    });
+  });
+
+  describe('type safety', () => {
+    it('should preserve generic type when parsing valid JSON', () => {
+      const validJson = '{"name": "test", "value": 123}';
+      const result = safeJsonParse<{ name: string; value: number }>(validJson);
+
+      expect(result).toEqual({ name: 'test', value: 123 });
+      // TypeScript should infer the correct type
+      expect(typeof result.name).toBe('string');
+      expect(typeof result.value).toBe('number');
+    });
+
+    it('should return fallback type when parsing fails', () => {
+      const invalidJson = 'invalid json';
+      const fallback = { error: 'fallback' } as const;
+
+      const result = safeJsonParse(invalidJson, fallback);
+
+      // jsonrepair returns the original string for completely invalid JSON
+      expect(result).toEqual('invalid json');
+      // TypeScript should preserve the fallback type
+      expect(typeof result).toBe('string');
+    });
+  });
+});

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

@@ -0,0 +1,45 @@
+/**
+ * @license
+ * Copyright 2025 Qwen
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { jsonrepair } from 'jsonrepair';
+
+/**
+ * Safely parse JSON string with jsonrepair fallback for malformed JSON.
+ * This function attempts to parse JSON normally first, and if that fails,
+ * it uses jsonrepair to fix common JSON formatting issues before parsing.
+ *
+ * @param jsonString - The JSON string to parse
+ * @param fallbackValue - The value to return if parsing fails completely
+ * @returns The parsed object or the fallback value
+ */
+export function safeJsonParse<T = Record<string, unknown>>(
+  jsonString: string,
+  fallbackValue: T = {} as T,
+): T {
+  if (!jsonString || typeof jsonString !== 'string') {
+    return fallbackValue;
+  }
+
+  try {
+    // First attempt: try normal JSON.parse
+    return JSON.parse(jsonString) as T;
+  } catch (error) {
+    try {
+      // Second attempt: use jsonrepair to fix common JSON issues
+      const repairedJson = jsonrepair(jsonString);
+
+      // jsonrepair always returns a string, so we need to parse it
+      return JSON.parse(repairedJson) as T;
+    } catch (repairError) {
+      console.error('Failed to parse JSON even with jsonrepair:', {
+        originalError: error,
+        repairError,
+        jsonString,
+      });
+      return fallbackValue;
+    }
+  }
+}