qwen-code/integration-tests/test-helper.ts

/**
 * @license
 * Copyright 2025 Google LLC
 * SPDX-License-Identifier: Apache-2.0
 */

import { spawn } from 'node:child_process';
import { mkdirSync, writeFileSync, readFileSync } from 'node:fs';
import { rm } from 'node:fs/promises';
import { join, dirname } from 'node:path';
import { fileURLToPath } from 'node:url';
import { env } from 'node:process';
import fs from 'node:fs';
import { EOL } from 'node:os';
import * as pty from '@lydell/node-pty';
import stripAnsi from 'strip-ansi';
import { vi } from 'vitest';
import {
  startFakeOpenAIServer,
  type FakeOpenAIServerOptions,
  type FakeOpenAIToolCall,
} from './fake-openai-server.js';
import {
  e2eRendererEnv,
  pickE2eRenderer,
  resolveE2eCliCommand,
} from './renderer-matrix.js';
import { E2E_MEMORY_SETTINGS_DEFAULTS } from './e2e-memory-defaults.js';

const __dirname = dirname(fileURLToPath(import.meta.url));

function sanitizeTestName(name: string) {
  return name
    .toLowerCase()
    .replace(/[^a-z0-9]/g, '-')
    .replace(/-+/g, '-');
}

// Helper to create detailed error messages
export function createToolCallErrorMessage(
  expectedTools: string | string[],
  // Callers build this by mapping `toolRequest.name` over the parsed
  // telemetry, where the name is optional. This is a failure message, so a
  // missing entry should print as `undefined` rather than force every call
  // site to filter first.
  foundTools: Array<string | undefined>,
  result: string,
) {
  const expectedStr = Array.isArray(expectedTools)
    ? expectedTools.join(' or ')
    : expectedTools;
  return (
    `Expected to find ${expectedStr} tool call(s). ` +
    `Found: ${foundTools.length > 0 ? foundTools.join(', ') : 'none'}. ` +
    `Output preview: ${result ? result.substring(0, 200) + '...' : 'no output'}`
  );
}

// Helper to print debug information when tests fail
export function printDebugInfo(
  rig: TestRig,
  result: string,
  context: Record<string, unknown> = {},
) {
  console.error('Test failed - Debug info:');
  console.error('Result length:', result.length);
  console.error('Result (first 500 chars):', result.substring(0, 500));
  console.error(
    'Result (last 500 chars):',
    result.substring(result.length - 500),
  );

  // Print any additional context provided
  Object.entries(context).forEach(([key, value]) => {
    console.error(`${key}:`, value);
  });

  // Check what tools were actually called
  const allTools = rig.readToolLogs();
  console.error(
    'All tool calls found:',
    allTools.map((t) => t.toolRequest.name),
  );

  return allTools;
}

// Helper to validate model output and warn about unexpected content
export function validateModelOutput(
  result: string,
  expectedContent: string | (string | RegExp)[] | null = null,
  testName = '',
) {
  // First, check if there's any output at all (this should fail the test if missing)
  if (!result || result.trim().length === 0) {
    throw new Error('Expected LLM to return some output');
  }

  // If expectedContent is provided, check for it and warn if missing
  if (expectedContent) {
    const contents = Array.isArray(expectedContent)
      ? expectedContent
      : [expectedContent];
    const missingContent = contents.filter((content) => {
      if (typeof content === 'string') {
        return !result.toLowerCase().includes(content.toLowerCase());
      } else if (content instanceof RegExp) {
        return !content.test(result);
      }
      return false;
    });

    if (missingContent.length > 0) {
      console.warn(
        `Warning: LLM did not include expected content in response: ${missingContent.join(
          ', ',
        )}.`,
        'This is not ideal but not a test failure.',
      );
      console.warn(
        'The tool was called successfully, which is the main requirement.',
      );
      return false;
    } else if (process.env['VERBOSE'] === 'true') {
      console.log(`${testName}: Model output validated successfully.`);
    }
    return true;
  }

  return true;
}

// Simulates typing a string one character at a time to avoid paste detection.
export async function type(ptyProcess: pty.IPty, text: string) {
  const delay = 5;
  for (const char of text) {
    ptyProcess.write(char);
    await new Promise((resolve) => setTimeout(resolve, delay));
  }
}

const SANDBOX_MODE = process.env['QWEN_SANDBOX']?.toLowerCase().trim();

export const IS_CONTAINER_SANDBOX =
  SANDBOX_MODE === 'docker' || SANDBOX_MODE === 'podman';

export const CONTAINER_SANDBOX_NO_PROXY =
  '127.0.0.1,localhost,host.docker.internal';

export function fakeServerHostOptions(): FakeOpenAIServerOptions | undefined {
  return IS_CONTAINER_SANDBOX
    ? { listenHost: '0.0.0.0', baseUrlHost: 'host.docker.internal' }
    : undefined;
}

// Sets NO_PROXY so a containerized CLI reaches the host-side fake server, and
// returns a restorer for the previous values. No-op outside a container sandbox.
export function applyContainerSandboxNoProxy(): () => void {
  if (!IS_CONTAINER_SANDBOX) {
    return () => {};
  }
  const savedNoProxy = process.env['NO_PROXY'];
  const savedNoProxyLower = process.env['no_proxy'];
  process.env['NO_PROXY'] = CONTAINER_SANDBOX_NO_PROXY;
  process.env['no_proxy'] = CONTAINER_SANDBOX_NO_PROXY;
  return () => {
    if (savedNoProxy === undefined) {
      delete process.env['NO_PROXY'];
    } else {
      process.env['NO_PROXY'] = savedNoProxy;
    }
    if (savedNoProxyLower === undefined) {
      delete process.env['no_proxy'];
    } else {
      process.env['no_proxy'] = savedNoProxyLower;
    }
  };
}

interface ParsedLog {
  attributes?: {
    'event.name'?: string;
    function_name?: string;
    function_args?: string;
    success?: boolean;
    duration_ms?: number;
    status?: string;
    'error.message'?: string;
    // Telemetry carries far more attributes than the tool-call subset named
    // above; callers reach them by key (`attributes['request_text']`). Every
    // value is `unknown` because nothing validates the payload shape.
    [key: string]: unknown;
  };
  scopeMetrics?: {
    metrics: {
      descriptor: {
        name: string;
      };
    }[];
  }[];
}

export class TestRig {
  bundlePath: string;
  testDir: string | null;
  testName?: string;
  _lastRunStdout?: string;
  _interactiveOutput = '';
  private readonly interactiveProcesses: pty.IPty[] = [];

  constructor() {
    this.bundlePath = join(__dirname, '..', 'dist/cli.js');
    this.testDir = null;
  }

  // Get timeout based on environment
  getDefaultTimeout() {
    if (env['CI']) return 60000; // 1 minute in CI
    if (env['QWEN_SANDBOX']) return 30000; // 30s in containers
    return 15000; // 15s locally
  }

  async setup(
    testName: string,
    options: { settings?: Record<string, unknown> } = {},
  ) {
    this.testName = testName;
    const sanitizedName = sanitizeTestName(testName);
    this.testDir = join(
      env['INTEGRATION_TEST_FILE_DIR']!,
      `${sanitizedName}-${process.pid}`,
    );
    // Same-name cases in one worker share this directory, and
    // cleanup() below keeps it whenever KEEP_OUTPUT is set — which CI always
    // sets. Reset it so a case never inherits the previous one's files; see the
    // SDK helper, where exactly that made a suite pass locally and fail in CI.
    await rm(this.testDir, { recursive: true, force: true });
    mkdirSync(this.testDir, { recursive: true });

    // Create a settings file to point the CLI to the local collector
    const qwenDir = join(this.testDir, '.qwen');
    mkdirSync(qwenDir, { recursive: true });
    // In sandbox mode, use an absolute path for telemetry inside the container
    // The container mounts the test directory at the same path as the host
    const telemetryPath = join(this.testDir, 'telemetry.log'); // Always use test directory for telemetry

    const optionsSettings = options.settings ?? {};
    const memorySettings =
      typeof optionsSettings['memory'] === 'object' &&
      optionsSettings['memory'] !== null
        ? (optionsSettings['memory'] as Record<string, unknown>)
        : {};

    const settings = {
      telemetry: {
        enabled: true,
        target: 'local',
        otlpEndpoint: '',
        outfile: telemetryPath,
      },
      sandbox: env.QWEN_SANDBOX !== 'false' ? env.QWEN_SANDBOX : false,
      ...options.settings, // Allow tests to override/add settings
      // Per-key merge: a suite opting back into one flag keeps the other off.
      memory: { ...E2E_MEMORY_SETTINGS_DEFAULTS, ...memorySettings },
    };
    writeFileSync(
      join(qwenDir, 'settings.json'),
      JSON.stringify(settings, null, 2),
    );
  }

  createFile(fileName: string, content: string) {
    const filePath = join(this.testDir!, fileName);
    writeFileSync(filePath, content);
    return filePath;
  }

  mkdir(dir: string) {
    mkdirSync(join(this.testDir!, dir), { recursive: true });
  }

  /**
   * The command and args to use to invoke Qwen Code CLI. Allows us to switch
   * between using the bundled gemini.js (the default) and using the installed
   * 'qwen' (used to verify npm bundles).
   */
  private _getCommandAndArgs(
    extraInitialArgs: string[] = [],
    options: { chatRecording?: boolean } = {},
  ): {
    command: string;
    initialArgs: string[];
  } {
    const isNpmReleaseTest =
      process.env.INTEGRATION_TEST_USE_INSTALLED_GEMINI === 'true';
    const command = isNpmReleaseTest ? 'qwen' : 'node';
    // Runs leave no conversation behind by default. A test that drives
    // `--continue` has to opt back in: without a recorded session there is
    // nothing to resume, and the resumed run then looks indistinguishable
    // from a fresh one.
    const recordingArgs = options.chatRecording ? [] : ['--no-chat-recording'];
    const initialArgs = isNpmReleaseTest
      ? [...recordingArgs, ...extraInitialArgs]
      : [this.bundlePath, ...recordingArgs, ...extraInitialArgs];
    return { command, initialArgs };
  }

  run(
    promptOrOptions:
      | string
      | { prompt?: string; stdin?: string; stdinDoesNotEnd?: boolean },
    ...args: string[]
  ): Promise<string> {
    const { command, initialArgs } = this._getCommandAndArgs(['--yolo']);
    const commandArgs = [...initialArgs];
    const execOptions: {
      cwd: string;
      encoding: 'utf-8';
      input?: string;
    } = {
      cwd: this.testDir!,
      encoding: 'utf-8',
    };

    if (typeof promptOrOptions === 'string') {
      commandArgs.push('--prompt', promptOrOptions);
    } else if (
      typeof promptOrOptions === 'object' &&
      promptOrOptions !== null
    ) {
      if (promptOrOptions.prompt) {
        commandArgs.push('--prompt', promptOrOptions.prompt);
      }
      if (promptOrOptions.stdin) {
        execOptions.input = promptOrOptions.stdin;
      }
    }

    commandArgs.push(...args);

    const child = spawn(command, commandArgs, {
      cwd: this.testDir!,
      stdio: 'pipe',
      env: process.env,
    });

    let stdout = '';
    let stderr = '';

    // Handle stdin if provided
    if (execOptions.input) {
      child.stdin!.write(execOptions.input);
    }

    const keepStdinOpen =
      typeof promptOrOptions === 'object' &&
      promptOrOptions !== null &&
      promptOrOptions.stdinDoesNotEnd === true;
    if (!keepStdinOpen) {
      child.stdin!.end();
    }

    child.stdout!.on('data', (data: Buffer) => {
      stdout += data;
      if (env['KEEP_OUTPUT'] === 'true' || env['VERBOSE'] === 'true') {
        process.stdout.write(data);
      }
    });

    child.stderr!.on('data', (data: Buffer) => {
      stderr += data;
      if (env['KEEP_OUTPUT'] === 'true' || env['VERBOSE'] === 'true') {
        process.stderr.write(data);
      }
    });

    const promise = new Promise<string>((resolve, reject) => {
      child.on('close', (code: number) => {
        if (code === 0) {
          // Store the raw stdout for Podman telemetry parsing
          this._lastRunStdout = stdout;

          // Filter out telemetry output when running with Podman
          // Podman seems to output telemetry to stdout even when writing to file
          let result = stdout;
          if (env['QWEN_SANDBOX'] === 'podman') {
            // Remove telemetry JSON objects from output
            // They are multi-line JSON objects that start with { and contain telemetry fields
            const lines = result.split(EOL);
            const filteredLines = [];
            let inTelemetryObject = false;
            let braceDepth = 0;

            for (const line of lines) {
              if (!inTelemetryObject && line.trim() === '{') {
                // Check if this might be start of telemetry object
                inTelemetryObject = true;
                braceDepth = 1;
              } else if (inTelemetryObject) {
                // Count braces to track nesting
                for (const char of line) {
                  if (char === '{') braceDepth++;
                  else if (char === '}') braceDepth--;
                }

                // Check if we've closed all braces
                if (braceDepth === 0) {
                  inTelemetryObject = false;
                  // Skip this line (the closing brace)
                  continue;
                }
              } else {
                // Not in telemetry object, keep the line
                filteredLines.push(line);
              }
            }

            result = filteredLines.join('\n');
          }

          // Check if this is a JSON output test - if so, don't include stderr
          // as it would corrupt the JSON
          const isJsonOutput =
            commandArgs.includes('--output-format') &&
            (commandArgs.includes('json') ||
              commandArgs.includes('stream-json'));

          // If we have stderr output and it's not a JSON test, include that also
          if (stderr && !isJsonOutput) {
            result += `\n\nStdErr:\n${stderr}`;
          }

          resolve(result);
        } else {
          // Check if this is a JSON output test - for JSON errors, the error is in stdout
          const isJsonOutputOnError =
            commandArgs.includes('--output-format') &&
            (commandArgs.includes('json') ||
              commandArgs.includes('stream-json'));

          // For JSON output tests, include stdout in the error message
          // as the error JSON is written to stdout
          if (isJsonOutputOnError && stdout) {
            reject(
              new Error(
                `Process exited with code ${code}:\nStdout:\n${stdout}\n\nStderr:\n${stderr}`,
              ),
            );
          } else {
            reject(new Error(`Process exited with code ${code}:\n${stderr}`));
          }
        }
      });
    });

    return promise;
  }

  runCommand(
    args: string[],
    options: { stdin?: string } = {},
  ): Promise<string> {
    const { command, initialArgs } = this._getCommandAndArgs();
    const commandArgs = [...initialArgs, ...args];

    const child = spawn(command, commandArgs, {
      cwd: this.testDir!,
      stdio: 'pipe',
    });

    let stdout = '';
    let stderr = '';

    if (options.stdin) {
      child.stdin!.write(options.stdin);
      child.stdin!.end();
    }

    child.stdout!.on('data', (data: Buffer) => {
      stdout += data;
      if (env.KEEP_OUTPUT === 'true' || env.VERBOSE === 'true') {
        process.stdout.write(data);
      }
    });

    child.stderr!.on('data', (data: Buffer) => {
      stderr += data;
      if (env.KEEP_OUTPUT === 'true' || env.VERBOSE === 'true') {
        process.stderr.write(data);
      }
    });

    const promise = new Promise<string>((resolve, reject) => {
      child.on('close', (code: number) => {
        if (code === 0) {
          this._lastRunStdout = stdout;
          let result = stdout;
          if (stderr) {
            result += `\n\nStdErr:\n${stderr}`;
          }
          resolve(result);
        } else {
          reject(new Error(`Process exited with code ${code}:\n${stderr}`));
        }
      });
    });

    return promise;
  }

  readFile(fileName: string) {
    const filePath = join(this.testDir!, fileName);
    const content = readFileSync(filePath, 'utf-8');
    if (env['KEEP_OUTPUT'] === 'true' || env['VERBOSE'] === 'true') {
      console.log(`--- FILE: ${filePath} ---`);
      console.log(content);
      console.log(`--- END FILE: ${filePath} ---`);
    }
    return content;
  }

  async cleanup() {
    // A session a test never closed keeps its CLI child forwarding PTY bytes
    // into this worker's stdout; after vitest tears the worker down those
    // writes EPIPE and fail an otherwise all-green run (#10969).
    for (const ptyProcess of this.interactiveProcesses.splice(0)) {
      try {
        ptyProcess.kill();
      } catch {
        // Process may have already exited
      }
    }

    // Clean up test directory
    if (this.testDir && !env['KEEP_OUTPUT']) {
      try {
        await rm(this.testDir, { recursive: true, force: true });
      } catch (error) {
        // Ignore cleanup errors
        if (env['VERBOSE'] === 'true') {
          console.warn('Cleanup warning:', (error as Error).message);
        }
      }
    }
  }

  async waitForTelemetryReady() {
    // Telemetry is always written to the test directory
    const logFilePath = join(this.testDir!, 'telemetry.log');

    // Wait for telemetry file to exist and have content
    await this.poll(
      () => {
        if (!fs.existsSync(logFilePath)) return false;
        try {
          const content = readFileSync(logFilePath, 'utf-8');
          // Check if file has meaningful content (at least one complete JSON object)
          return content.includes('"event.name"');
        } catch {
          return false;
        }
      },
      2000, // 2 seconds max - reduced since telemetry should flush on exit now
      100, // check every 100ms
    );
  }

  async waitForTelemetryEvent(eventName: string, timeout?: number) {
    if (!timeout) {
      timeout = this.getDefaultTimeout();
    }

    await this.waitForTelemetryReady();

    return this.poll(
      () => {
        const logs = this._readAndParseTelemetryLog();
        return logs.some(
          (logData) =>
            logData.attributes &&
            logData.attributes['event.name'] === `qwen-code.${eventName}`,
        );
      },
      timeout,
      100,
    );
  }

  async waitForToolCall(toolName: string, timeout?: number) {
    // Use environment-specific timeout
    if (!timeout) {
      timeout = this.getDefaultTimeout();
    }

    // Wait for telemetry to be ready before polling for tool calls
    await this.waitForTelemetryReady();

    return this.poll(
      () => {
        const toolLogs = this.readToolLogs();
        return toolLogs.some((log) => log.toolRequest.name === toolName);
      },
      timeout,
      100,
    );
  }

  async waitForAnyToolCall(toolNames: string[], timeout?: number) {
    // Use environment-specific timeout
    if (!timeout) {
      timeout = this.getDefaultTimeout();
    }

    // Wait for telemetry to be ready before polling for tool calls
    await this.waitForTelemetryReady();

    return this.poll(
      () => {
        const toolLogs = this.readToolLogs();
        return toolNames.some((name) =>
          toolLogs.some((log) => log.toolRequest.name === name),
        );
      },
      timeout,
      100,
    );
  }

  async poll(
    predicate: () => boolean,
    timeout: number,
    interval: number,
  ): Promise<boolean> {
    const startTime = Date.now();
    let attempts = 0;
    let lastError: unknown;
    while (Date.now() - startTime < timeout) {
      attempts++;
      try {
        const result = predicate();
        if (env['VERBOSE'] === 'true' && attempts % 5 === 0) {
          console.log(
            `Poll attempt ${attempts}: ${result ? 'success' : 'waiting...'}`,
          );
        }
        if (result) {
          lastError = undefined;
          return true;
        }
      } catch (err) {
        lastError = err;
        if (env['VERBOSE'] === 'true') {
          console.log(`Poll attempt ${attempts}: predicate threw: ${err}`);
        }
      }
      await new Promise((resolve) => setTimeout(resolve, interval));
    }
    if (lastError) {
      console.log(
        `Poll timed out after ${attempts} attempts. Last error:`,
        lastError,
      );
    } else if (env['VERBOSE'] === 'true') {
      console.log(`Poll timed out after ${attempts} attempts`);
    }
    return false;
  }

  _parseToolLogsFromStdout(stdout: string) {
    const logs: {
      timestamp: number;
      toolRequest: {
        name: string;
        args: string;
        success: boolean;
        duration_ms: number;
        status?: string;
        error?: string;
      };
    }[] = [];

    // The console output from Podman is JavaScript object notation, not JSON
    // Look for tool call events in the output
    // Updated regex to handle tool names with hyphens and underscores
    const toolCallPattern =
      /body:\s*'Tool call:\s*([\w-]+)\..*?Success:\s*(\w+)\..*?Duration:\s*(\d+)ms\.'/g;
    const matches = [...stdout.matchAll(toolCallPattern)];

    for (const match of matches) {
      const toolName = match[1];
      const success = match[2] === 'true';
      const duration = parseInt(match[3], 10);

      // Try to find function_args nearby
      const matchIndex = match.index || 0;
      const contextStart = Math.max(0, matchIndex - 500);
      const contextEnd = Math.min(stdout.length, matchIndex + 500);
      const context = stdout.substring(contextStart, contextEnd);

      // Look for function_args in the context
      let args = '{}';
      const argsMatch = context.match(/function_args:\s*'([^']+)'/);
      if (argsMatch) {
        args = argsMatch[1];
      }

      // Also try to find function_name to double-check
      // Updated regex to handle tool names with hyphens and underscores
      const nameMatch = context.match(/function_name:\s*'([\w-]+)'/);
      const actualToolName = nameMatch ? nameMatch[1] : toolName;

      logs.push({
        timestamp: Date.now(),
        toolRequest: {
          name: actualToolName,
          args: args,
          success: success,
          duration_ms: duration,
        },
      });
    }

    // If no matches found with the simple pattern, try the JSON parsing approach
    // in case the format changes
    if (logs.length === 0) {
      const lines = stdout.split(EOL);
      let currentObject = '';
      let inObject = false;
      let braceDepth = 0;

      for (const line of lines) {
        if (!inObject && line.trim() === '{') {
          inObject = true;
          braceDepth = 1;
          currentObject = line + '\n';
        } else if (inObject) {
          currentObject += line + '\n';

          // Count braces
          for (const char of line) {
            if (char === '{') braceDepth++;
            else if (char === '}') braceDepth--;
          }

          // If we've closed all braces, try to parse the object
          if (braceDepth === 0) {
            inObject = false;
            try {
              const obj = JSON.parse(currentObject);

              // Check for tool call in different formats
              if (
                obj.body &&
                obj.body.includes('Tool call:') &&
                obj.attributes
              ) {
                const bodyMatch = obj.body.match(/Tool call: (\w+)\./);
                if (bodyMatch) {
                  logs.push({
                    timestamp: obj.timestamp || Date.now(),
                    toolRequest: {
                      name: bodyMatch[1],
                      args: obj.attributes.function_args || '{}',
                      success: obj.attributes.success !== false,
                      duration_ms: obj.attributes.duration_ms || 0,
                    },
                  });
                }
              } else if (
                obj.attributes &&
                obj.attributes['event.name'] === 'qwen-code.tool_call'
              ) {
                logs.push({
                  timestamp: obj.attributes['event.timestamp'],
                  toolRequest: {
                    name: obj.attributes.function_name,
                    args: obj.attributes.function_args,
                    success: obj.attributes.success,
                    duration_ms: obj.attributes.duration_ms,
                  },
                });
              }
            } catch {
              // Not valid JSON
            }
            currentObject = '';
          }
        }
      }
    }

    return logs;
  }

  private _readAndParseTelemetryLog(): ParsedLog[] {
    // Telemetry is always written to the test directory
    const logFilePath = join(this.testDir!, 'telemetry.log');

    if (!logFilePath || !fs.existsSync(logFilePath)) {
      return [];
    }

    const content = readFileSync(logFilePath, 'utf-8');

    // Split the content into individual JSON objects
    // They are separated by "}\n{"
    const jsonObjects = content
      .split(/}\n{/)
      .map((obj, index, array) => {
        // Add back the braces we removed during split
        if (index > 0) obj = '{' + obj;
        if (index < array.length - 1) obj = obj + '}';
        return obj.trim();
      })
      .filter((obj) => obj);

    const logs: ParsedLog[] = [];

    for (const jsonStr of jsonObjects) {
      try {
        const logData = JSON.parse(jsonStr);
        logs.push(logData);
      } catch (e) {
        // Skip objects that aren't valid JSON
        if (env.VERBOSE === 'true') {
          console.error('Failed to parse telemetry object:', e);
        }
      }
    }

    return logs;
  }

  readToolLogs() {
    // For Podman, first check if telemetry file exists and has content
    // If not, fall back to parsing from stdout
    if (env['QWEN_SANDBOX'] === 'podman') {
      // Try reading from file first
      const logFilePath = join(this.testDir!, 'telemetry.log');

      if (fs.existsSync(logFilePath)) {
        try {
          const content = readFileSync(logFilePath, 'utf-8');
          if (content && content.includes('"event.name"')) {
            // File has content, use normal file parsing
            // Continue to the normal file parsing logic below
          } else if (this._lastRunStdout) {
            // File exists but is empty or doesn't have events, parse from stdout
            return this._parseToolLogsFromStdout(this._lastRunStdout);
          }
        } catch {
          // Error reading file, fall back to stdout
          if (this._lastRunStdout) {
            return this._parseToolLogsFromStdout(this._lastRunStdout);
          }
        }
      } else if (this._lastRunStdout) {
        // No file exists, parse from stdout
        return this._parseToolLogsFromStdout(this._lastRunStdout);
      }
    }

    const parsedLogs = this._readAndParseTelemetryLog();
    // Every field is optional because it is copied straight out of the
    // telemetry attributes, which nothing validates. The stdout fallback above
    // reconstructs the same fields from a regex and can promise them; this
    // branch cannot, and claiming otherwise just moved the `undefined` past
    // the type checker into the assertions.
    const logs: {
      toolRequest: {
        name?: string;
        args?: string;
        success?: boolean;
        duration_ms?: number;
        status?: string;
        error?: string;
      };
    }[] = [];

    for (const logData of parsedLogs) {
      // Look for tool call logs
      if (
        logData.attributes &&
        logData.attributes['event.name'] === 'qwen-code.tool_call'
      ) {
        const toolName = logData.attributes.function_name;
        logs.push({
          toolRequest: {
            name: toolName,
            args: logData.attributes.function_args,
            success: logData.attributes.success,
            duration_ms: logData.attributes.duration_ms,
            status: logData.attributes.status,
            error: logData.attributes['error.message'],
          },
        });
      }
    }

    return logs;
  }

  // Returns the parsed log, not a bare record: callers want `.attributes`,
  // and `Record<string, unknown>` hid that the value already has a shape.
  readLastApiRequest(): ParsedLog | null {
    const logs = this._readAndParseTelemetryLog();
    const apiRequests = logs.filter(
      (logData) =>
        logData.attributes &&
        logData.attributes['event.name'] === 'qwen-code.api_request',
    );
    return apiRequests.pop() || null;
  }

  // Unlike waitForTelemetryEvent's boolean poll, this exposes the latest
  // matching payload so integration tests can assert event semantics.
  readTelemetryEvent(eventName: string): ParsedLog | null {
    const logs = this._readAndParseTelemetryLog();
    const events = logs.filter(
      (logData) =>
        logData.attributes &&
        logData.attributes['event.name'] === `qwen-code.${eventName}`,
    );
    return events.pop() || null;
  }

  readMetric(metricName: string): Record<string, unknown> | null {
    const logs = this._readAndParseTelemetryLog();
    for (const logData of logs) {
      if (logData.scopeMetrics) {
        for (const scopeMetric of logData.scopeMetrics) {
          for (const metric of scopeMetric.metrics) {
            if (metric.descriptor.name === `qwen-code.${metricName}`) {
              return metric;
            }
          }
        }
      }
    }
    return null;
  }

  async waitForText(text: string, timeout?: number): Promise<boolean> {
    if (!timeout) {
      timeout = this.getDefaultTimeout();
    }
    return this.poll(
      () =>
        stripAnsi(this._interactiveOutput)
          .toLowerCase()
          .includes(text.toLowerCase()),
      timeout,
      200,
    );
  }

  runInteractive(...args: string[]): {
    ptyProcess: pty.IPty;
    promise: Promise<{ exitCode: number; signal?: number; output: string }>;
  } {
    return this.runInteractiveWith({}, ...args);
  }

  /**
   * `runInteractive` with the launch knobs it does not expose. Currently just
   * `chatRecording`, which a `--continue` test needs so the first session is
   * on disk for the second one to resume.
   */
  runInteractiveWith(
    options: { chatRecording?: boolean },
    ...args: string[]
  ): {
    ptyProcess: pty.IPty;
    promise: Promise<{ exitCode: number; signal?: number; output: string }>;
  } {
    const renderer = pickE2eRenderer();
    const { command: cliCommand, initialArgs } = this._getCommandAndArgs(
      ['--yolo'],
      options,
    );
    // The renderer matrix swaps node for bun only when driving the repo
    // bundle directly; installed-release runs keep their own launcher and
    // still get the pinned QWEN_TUI_RENDERER below.
    const isNpmRelease =
      process.env.INTEGRATION_TEST_USE_INSTALLED_GEMINI === 'true';
    const command = isNpmRelease ? cliCommand : resolveE2eCliCommand(renderer);
    const commandArgs = [...initialArgs, ...args];

    this._interactiveOutput = ''; // Reset output for the new run

    const ptyProcess = pty.spawn(command, commandArgs, {
      name: 'xterm-color',
      cols: 80,
      rows: 30,
      cwd: this.testDir!,
      env: {
        ...process.env,
        ...e2eRendererEnv(renderer),
      } as { [key: string]: string },
    });
    this.interactiveProcesses.push(ptyProcess);

    ptyProcess.onData((data) => {
      this._interactiveOutput += data;
      if (env.KEEP_OUTPUT === 'true' || env.VERBOSE === 'true') {
        process.stdout.write(data);
      }
    });

    const promise = new Promise<{
      exitCode: number;
      signal?: number;
      output: string;
    }>((resolve) => {
      ptyProcess.onExit(({ exitCode, signal }) => {
        resolve({ exitCode, signal, output: this._interactiveOutput });
      });
    });

    return { ptyProcess, promise };
  }
}

export async function runForcedToolCallScenario(options: {
  rig: TestRig;
  toolCall: FakeOpenAIToolCall;
  prompt: string;
  finalResponse: string;
}): Promise<Array<Record<string, unknown>>> {
  const { rig, toolCall, prompt, finalResponse } = options;
  let streamingRequestIndex = 0;
  const fakeServer = await startFakeOpenAIServer(({ body }) => {
    if (body['stream'] !== true) {
      return { content: '{"selected_memories":[]}' };
    }
    if (streamingRequestIndex++ === 0) {
      return { toolCalls: [toolCall] };
    }
    return { content: finalResponse };
  }, fakeServerHostOptions());

  const noProxy = IS_CONTAINER_SANDBOX
    ? CONTAINER_SANDBOX_NO_PROXY
    : '127.0.0.1,localhost';
  vi.stubEnv('OPENAI_API_KEY', 'fake-key');
  vi.stubEnv('OPENAI_BASE_URL', fakeServer.baseUrl);
  vi.stubEnv('OPENAI_MODEL', 'fake-model');
  vi.stubEnv('QWEN_MODEL', 'fake-model');
  vi.stubEnv('QWEN_HOME', join(rig.testDir!, '.qwen-home'));
  vi.stubEnv('QWEN_RUNTIME_DIR', join(rig.testDir!, '.qwen-home'));
  vi.stubEnv('QWEN_CODE_MODELS_DEV_REFRESH', 'off');
  vi.stubEnv('NO_PROXY', noProxy);
  vi.stubEnv('no_proxy', noProxy);

  try {
    // Explicit CLI flags outrank a developer's ~/.qwen/settings.json
    // (settings.model.name beats the OPENAI_MODEL env var and can silently
    // route the run to a real model endpoint instead of the fake server).
    await rig.run(
      prompt,
      '--auth-type',
      'openai',
      '--model',
      'fake-model',
      '--openai-base-url',
      fakeServer.baseUrl,
      '--openai-api-key',
      'fake-key',
    );
    return fakeServer.requests
      .filter(({ body }) => body['stream'] === true)
      .map(({ body }) => body);
  } finally {
    await fakeServer.close();
  }
}