@anh3d0nic/qwen-code-termux-ice 14.0.0 → 16.0.0

package/packages/core/src/core/coreToolScheduler.ts

@@ -1,1406 +0,0 @@
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import type {
-  ToolCallRequestInfo,
-  ToolCallResponseInfo,
-  ToolCallConfirmationDetails,
-  ToolResult,
-  ToolResultDisplay,
-  ToolRegistry,
-  EditorType,
-  Config,
-  ToolConfirmationPayload,
-  AnyDeclarativeTool,
-  AnyToolInvocation,
-  ChatRecordingService,
-} from '../index.js';
-import { createDebugLogger } from '../utils/debugLogger.js';
-
-const debugLogger = createDebugLogger('TOOL_SCHEDULER');
-import {
-  ToolConfirmationOutcome,
-  ApprovalMode,
-  logToolCall,
-  ReadFileTool,
-  ToolErrorType,
-  ToolCallEvent,
-  ShellTool,
-  logToolOutputTruncated,
-  ToolOutputTruncatedEvent,
-  InputFormat,
-  Kind,
-  SkillTool,
-} from '../index.js';
-import type {
-  FunctionResponse,
-  FunctionResponsePart,
-  Part,
-  PartListUnion,
-} from '@google/genai';
-import { ToolNames } from '../tools/tool-names.js';
-import { getResponseTextFromParts } from '../utils/generateContentResponseUtilities.js';
-import type { ModifyContext } from '../tools/modifiable-tool.js';
-import {
-  isModifiableDeclarativeTool,
-  modifyWithEditor,
-} from '../tools/modifiable-tool.js';
-import * as Diff from 'diff';
-import * as fs from 'node:fs/promises';
-import * as path from 'node:path';
-import { doesToolInvocationMatch } from '../utils/tool-utils.js';
-import levenshtein from 'fast-levenshtein';
-import { getPlanModeSystemReminder } from './prompts.js';
-import { ShellToolInvocation } from '../tools/shell.js';
-
-const TRUNCATION_PARAM_GUIDANCE =
-  'Note: Your previous response was truncated due to max_tokens limit, ' +
-  'which likely caused incomplete tool call parameters. ' +
-  'Please retry the tool call with complete parameters. ' +
-  'If the content is too large for a single response, ' +
-  'consider splitting it into smaller parts.';
-
-const TRUNCATION_EDIT_REJECTION =
-  'Your previous response was truncated due to max_tokens limit, ' +
-  'which likely produced incomplete file content. ' +
-  'The tool call has been rejected to prevent writing ' +
-  'truncated content to the file. ' +
-  'Please retry the tool call with complete content. ' +
-  'If the content is too large for a single response, ' +
-  'consider splitting it into smaller parts ' +
-  '(e.g., write_file for initial content, then edit for additions).';
-
-export type ValidatingToolCall = {
-  status: 'validating';
-  request: ToolCallRequestInfo;
-  tool: AnyDeclarativeTool;
-  invocation: AnyToolInvocation;
-  startTime?: number;
-  outcome?: ToolConfirmationOutcome;
-};
-
-export type ScheduledToolCall = {
-  status: 'scheduled';
-  request: ToolCallRequestInfo;
-  tool: AnyDeclarativeTool;
-  invocation: AnyToolInvocation;
-  startTime?: number;
-  outcome?: ToolConfirmationOutcome;
-};
-
-export type ErroredToolCall = {
-  status: 'error';
-  request: ToolCallRequestInfo;
-  response: ToolCallResponseInfo;
-  tool?: AnyDeclarativeTool;
-  durationMs?: number;
-  outcome?: ToolConfirmationOutcome;
-};
-
-export type SuccessfulToolCall = {
-  status: 'success';
-  request: ToolCallRequestInfo;
-  tool: AnyDeclarativeTool;
-  response: ToolCallResponseInfo;
-  invocation: AnyToolInvocation;
-  durationMs?: number;
-  outcome?: ToolConfirmationOutcome;
-};
-
-export type ExecutingToolCall = {
-  status: 'executing';
-  request: ToolCallRequestInfo;
-  tool: AnyDeclarativeTool;
-  invocation: AnyToolInvocation;
-  liveOutput?: ToolResultDisplay;
-  startTime?: number;
-  outcome?: ToolConfirmationOutcome;
-  pid?: number;
-};
-
-export type CancelledToolCall = {
-  status: 'cancelled';
-  request: ToolCallRequestInfo;
-  response: ToolCallResponseInfo;
-  tool: AnyDeclarativeTool;
-  invocation: AnyToolInvocation;
-  durationMs?: number;
-  outcome?: ToolConfirmationOutcome;
-};
-
-export type WaitingToolCall = {
-  status: 'awaiting_approval';
-  request: ToolCallRequestInfo;
-  tool: AnyDeclarativeTool;
-  invocation: AnyToolInvocation;
-  confirmationDetails: ToolCallConfirmationDetails;
-  startTime?: number;
-  outcome?: ToolConfirmationOutcome;
-};
-
-export type Status = ToolCall['status'];
-
-export type ToolCall =
-  | ValidatingToolCall
-  | ScheduledToolCall
-  | ErroredToolCall
-  | SuccessfulToolCall
-  | ExecutingToolCall
-  | CancelledToolCall
-  | WaitingToolCall;
-
-export type CompletedToolCall =
-  | SuccessfulToolCall
-  | CancelledToolCall
-  | ErroredToolCall;
-
-export type ConfirmHandler = (
-  toolCall: WaitingToolCall,
-) => Promise<ToolConfirmationOutcome>;
-
-export type OutputUpdateHandler = (
-  toolCallId: string,
-  outputChunk: ToolResultDisplay,
-) => void;
-
-export type AllToolCallsCompleteHandler = (
-  completedToolCalls: CompletedToolCall[],
-) => Promise<void>;
-
-export type ToolCallsUpdateHandler = (toolCalls: ToolCall[]) => void;
-
-/**
- * Formats tool output for a Gemini FunctionResponse.
- */
-function createFunctionResponsePart(
-  callId: string,
-  toolName: string,
-  output: string,
-  mediaParts?: FunctionResponsePart[],
-): Part {
-  const functionResponse: FunctionResponse = {
-    id: callId,
-    name: toolName,
-    response: { output },
-    ...(mediaParts && mediaParts.length > 0 ? { parts: mediaParts } : {}),
-  };
-
-  return {
-    functionResponse,
-  };
-}
-
-export function convertToFunctionResponse(
-  toolName: string,
-  callId: string,
-  llmContent: PartListUnion,
-): Part[] {
-  const contentToProcess =
-    Array.isArray(llmContent) && llmContent.length === 1
-      ? llmContent[0]
-      : llmContent;
-
-  if (typeof contentToProcess === 'string') {
-    return [createFunctionResponsePart(callId, toolName, contentToProcess)];
-  }
-
-  if (Array.isArray(contentToProcess)) {
-    // Extract text and media from all parts so that EVERYTHING is inside
-    // the FunctionResponse.
-    const textParts: string[] = [];
-    const mediaParts: FunctionResponsePart[] = [];
-
-    for (const part of toParts(contentToProcess)) {
-      if (part.text !== undefined) {
-        textParts.push(part.text);
-      } else if (part.inlineData) {
-        mediaParts.push({ inlineData: part.inlineData });
-      } else if (part.fileData) {
-        mediaParts.push({ fileData: part.fileData });
-      }
-      // Other exotic part types (e.g. functionCall) are intentionally
-      // dropped here – they should not appear inside tool results.
-    }
-
-    const output =
-      textParts.length > 0 ? textParts.join('\n') : 'Tool execution succeeded.';
-    return [createFunctionResponsePart(callId, toolName, output, mediaParts)];
-  }
-
-  // After this point, contentToProcess is a single Part object.
-  if (contentToProcess.functionResponse) {
-    if (contentToProcess.functionResponse.response?.['content']) {
-      const stringifiedOutput =
-        getResponseTextFromParts(
-          contentToProcess.functionResponse.response['content'] as Part[],
-        ) || '';
-      return [createFunctionResponsePart(callId, toolName, stringifiedOutput)];
-    }
-    // It's a functionResponse that we should pass through as is.
-    return [contentToProcess];
-  }
-
-  if (contentToProcess.inlineData || contentToProcess.fileData) {
-    const mediaParts: FunctionResponsePart[] = [];
-    if (contentToProcess.inlineData) {
-      mediaParts.push({ inlineData: contentToProcess.inlineData });
-    }
-    if (contentToProcess.fileData) {
-      mediaParts.push({ fileData: contentToProcess.fileData });
-    }
-
-    const functionResponse = createFunctionResponsePart(
-      callId,
-      toolName,
-      '',
-      mediaParts,
-    );
-    return [functionResponse];
-  }
-
-  if (contentToProcess.text !== undefined) {
-    return [
-      createFunctionResponsePart(callId, toolName, contentToProcess.text),
-    ];
-  }
-
-  // Default case for other kinds of parts.
-  return [
-    createFunctionResponsePart(callId, toolName, 'Tool execution succeeded.'),
-  ];
-}
-
-function toParts(input: PartListUnion): Part[] {
-  const parts: Part[] = [];
-  for (const part of Array.isArray(input) ? input : [input]) {
-    if (typeof part === 'string') {
-      parts.push({ text: part });
-    } else if (part) {
-      parts.push(part);
-    }
-  }
-  return parts;
-}
-
-const createErrorResponse = (
-  request: ToolCallRequestInfo,
-  error: Error,
-  errorType: ToolErrorType | undefined,
-): ToolCallResponseInfo => ({
-  callId: request.callId,
-  error,
-  responseParts: [
-    {
-      functionResponse: {
-        id: request.callId,
-        name: request.name,
-        response: { error: error.message },
-      },
-    },
-  ],
-  resultDisplay: error.message,
-  errorType,
-  contentLength: error.message.length,
-});
-
-export async function truncateAndSaveToFile(
-  content: string,
-  callId: string,
-  projectTempDir: string,
-  threshold: number,
-  truncateLines: number,
-): Promise<{ content: string; outputFile?: string }> {
-  if (content.length <= threshold) {
-    return { content };
-  }
-
-  let lines = content.split('\n');
-  let fileContent = content;
-
-  // If the content is long but has few lines, wrap it to enable line-based truncation.
-  if (lines.length <= truncateLines) {
-    const wrapWidth = 120; // A reasonable width for wrapping.
-    const wrappedLines: string[] = [];
-    for (const line of lines) {
-      if (line.length > wrapWidth) {
-        for (let i = 0; i < line.length; i += wrapWidth) {
-          wrappedLines.push(line.substring(i, i + wrapWidth));
-        }
-      } else {
-        wrappedLines.push(line);
-      }
-    }
-    lines = wrappedLines;
-    fileContent = lines.join('\n');
-  }
-
-  const head = Math.floor(truncateLines / 5);
-  const beginning = lines.slice(0, head);
-  const end = lines.slice(-(truncateLines - head));
-  const truncatedContent =
-    beginning.join('\n') + '\n... [CONTENT TRUNCATED] ...\n' + end.join('\n');
-
-  // Sanitize callId to prevent path traversal.
-  const safeFileName = `${path.basename(callId)}.output`;
-  const outputFile = path.join(projectTempDir, safeFileName);
-  try {
-    await fs.writeFile(outputFile, fileContent);
-
-    return {
-      content: `Tool output was too large and has been truncated.
-The full output has been saved to: ${outputFile}
-To read the complete output, use the ${ReadFileTool.Name} tool with the absolute file path above.
-The truncated output below shows the beginning and end of the content. The marker '... [CONTENT TRUNCATED] ...' indicates where content was removed.
-This allows you to efficiently examine different parts of the output without loading the entire file.
-Truncated part of the output:
-${truncatedContent}`,
-      outputFile,
-    };
-  } catch (_error) {
-    return {
-      content:
-        truncatedContent + `\n[Note: Could not save full output to file]`,
-    };
-  }
-}
-
-interface CoreToolSchedulerOptions {
-  config: Config;
-  outputUpdateHandler?: OutputUpdateHandler;
-  onAllToolCallsComplete?: AllToolCallsCompleteHandler;
-  onToolCallsUpdate?: ToolCallsUpdateHandler;
-  getPreferredEditor: () => EditorType | undefined;
-  onEditorClose: () => void;
-  /**
-   * Optional recording service. If provided, tool results will be recorded.
-   */
-  chatRecordingService?: ChatRecordingService;
-}
-
-export class CoreToolScheduler {
-  private toolRegistry: ToolRegistry;
-  private toolCalls: ToolCall[] = [];
-  private outputUpdateHandler?: OutputUpdateHandler;
-  private onAllToolCallsComplete?: AllToolCallsCompleteHandler;
-  private onToolCallsUpdate?: ToolCallsUpdateHandler;
-  private getPreferredEditor: () => EditorType | undefined;
-  private config: Config;
-  private onEditorClose: () => void;
-  private chatRecordingService?: ChatRecordingService;
-  private isFinalizingToolCalls = false;
-  private isScheduling = false;
-  private requestQueue: Array<{
-    request: ToolCallRequestInfo | ToolCallRequestInfo[];
-    signal: AbortSignal;
-    resolve: () => void;
-    reject: (reason?: Error) => void;
-  }> = [];
-
-  constructor(options: CoreToolSchedulerOptions) {
-    this.config = options.config;
-    this.toolRegistry = options.config.getToolRegistry();
-    this.outputUpdateHandler = options.outputUpdateHandler;
-    this.onAllToolCallsComplete = options.onAllToolCallsComplete;
-    this.onToolCallsUpdate = options.onToolCallsUpdate;
-    this.getPreferredEditor = options.getPreferredEditor;
-    this.onEditorClose = options.onEditorClose;
-    this.chatRecordingService = options.chatRecordingService;
-  }
-
-  private setStatusInternal(
-    targetCallId: string,
-    status: 'success',
-    response: ToolCallResponseInfo,
-  ): void;
-  private setStatusInternal(
-    targetCallId: string,
-    status: 'awaiting_approval',
-    confirmationDetails: ToolCallConfirmationDetails,
-  ): void;
-  private setStatusInternal(
-    targetCallId: string,
-    status: 'error',
-    response: ToolCallResponseInfo,
-  ): void;
-  private setStatusInternal(
-    targetCallId: string,
-    status: 'cancelled',
-    reason: string,
-  ): void;
-  private setStatusInternal(
-    targetCallId: string,
-    status: 'executing' | 'scheduled' | 'validating',
-  ): void;
-  private setStatusInternal(
-    targetCallId: string,
-    newStatus: Status,
-    auxiliaryData?: unknown,
-  ): void {
-    this.toolCalls = this.toolCalls.map((currentCall) => {
-      if (
-        currentCall.request.callId !== targetCallId ||
-        currentCall.status === 'success' ||
-        currentCall.status === 'error' ||
-        currentCall.status === 'cancelled'
-      ) {
-        return currentCall;
-      }
-
-      // currentCall is a non-terminal state here and should have startTime and tool.
-      const existingStartTime = currentCall.startTime;
-      const toolInstance = currentCall.tool;
-      const invocation = currentCall.invocation;
-
-      const outcome = currentCall.outcome;
-
-      switch (newStatus) {
-        case 'success': {
-          const durationMs = existingStartTime
-            ? Date.now() - existingStartTime
-            : undefined;
-          return {
-            request: currentCall.request,
-            tool: toolInstance,
-            invocation,
-            status: 'success',
-            response: auxiliaryData as ToolCallResponseInfo,
-            durationMs,
-            outcome,
-          } as SuccessfulToolCall;
-        }
-        case 'error': {
-          const durationMs = existingStartTime
-            ? Date.now() - existingStartTime
-            : undefined;
-          return {
-            request: currentCall.request,
-            status: 'error',
-            tool: toolInstance,
-            response: auxiliaryData as ToolCallResponseInfo,
-            durationMs,
-            outcome,
-          } as ErroredToolCall;
-        }
-        case 'awaiting_approval':
-          return {
-            request: currentCall.request,
-            tool: toolInstance,
-            status: 'awaiting_approval',
-            confirmationDetails: auxiliaryData as ToolCallConfirmationDetails,
-            startTime: existingStartTime,
-            outcome,
-            invocation,
-          } as WaitingToolCall;
-        case 'scheduled':
-          return {
-            request: currentCall.request,
-            tool: toolInstance,
-            status: 'scheduled',
-            startTime: existingStartTime,
-            outcome,
-            invocation,
-          } as ScheduledToolCall;
-        case 'cancelled': {
-          const durationMs = existingStartTime
-            ? Date.now() - existingStartTime
-            : undefined;
-
-          // Preserve diff for cancelled edit operations
-          let resultDisplay: ToolResultDisplay | undefined = undefined;
-          if (currentCall.status === 'awaiting_approval') {
-            const waitingCall = currentCall as WaitingToolCall;
-            if (waitingCall.confirmationDetails.type === 'edit') {
-              resultDisplay = {
-                fileDiff: waitingCall.confirmationDetails.fileDiff,
-                fileName: waitingCall.confirmationDetails.fileName,
-                originalContent:
-                  waitingCall.confirmationDetails.originalContent,
-                newContent: waitingCall.confirmationDetails.newContent,
-              };
-            }
-          } else if (currentCall.status === 'executing') {
-            // If the tool was streaming live output, preserve the latest
-            // output so the UI can continue to show it after cancellation.
-            const executingCall = currentCall as ExecutingToolCall;
-            if (executingCall.liveOutput !== undefined) {
-              resultDisplay = executingCall.liveOutput;
-            }
-          }
-
-          const errorMessage = `[Operation Cancelled] Reason: ${auxiliaryData}`;
-          return {
-            request: currentCall.request,
-            tool: toolInstance,
-            invocation,
-            status: 'cancelled',
-            response: {
-              callId: currentCall.request.callId,
-              responseParts: [
-                {
-                  functionResponse: {
-                    id: currentCall.request.callId,
-                    name: currentCall.request.name,
-                    response: {
-                      error: errorMessage,
-                    },
-                  },
-                },
-              ],
-              resultDisplay,
-              error: undefined,
-              errorType: undefined,
-              contentLength: errorMessage.length,
-            },
-            durationMs,
-            outcome,
-          } as CancelledToolCall;
-        }
-        case 'validating':
-          return {
-            request: currentCall.request,
-            tool: toolInstance,
-            status: 'validating',
-            startTime: existingStartTime,
-            outcome,
-            invocation,
-          } as ValidatingToolCall;
-        case 'executing':
-          return {
-            request: currentCall.request,
-            tool: toolInstance,
-            status: 'executing',
-            startTime: existingStartTime,
-            outcome,
-            invocation,
-          } as ExecutingToolCall;
-        default: {
-          const exhaustiveCheck: never = newStatus;
-          return exhaustiveCheck;
-        }
-      }
-    });
-    this.notifyToolCallsUpdate();
-    this.checkAndNotifyCompletion();
-  }
-
-  private setArgsInternal(targetCallId: string, args: unknown): void {
-    this.toolCalls = this.toolCalls.map((call) => {
-      // We should never be asked to set args on an ErroredToolCall, but
-      // we guard for the case anyways.
-      if (call.request.callId !== targetCallId || call.status === 'error') {
-        return call;
-      }
-
-      const invocationOrError = this.buildInvocation(
-        call.tool,
-        args as Record<string, unknown>,
-      );
-      if (invocationOrError instanceof Error) {
-        const response = createErrorResponse(
-          call.request,
-          invocationOrError,
-          ToolErrorType.INVALID_TOOL_PARAMS,
-        );
-        return {
-          request: { ...call.request, args: args as Record<string, unknown> },
-          status: 'error',
-          tool: call.tool,
-          response,
-        } as ErroredToolCall;
-      }
-
-      return {
-        ...call,
-        request: { ...call.request, args: args as Record<string, unknown> },
-        invocation: invocationOrError,
-      };
-    });
-  }
-
-  private isRunning(): boolean {
-    return (
-      this.isFinalizingToolCalls ||
-      this.toolCalls.some(
-        (call) =>
-          call.status === 'executing' || call.status === 'awaiting_approval',
-      )
-    );
-  }
-
-  private buildInvocation(
-    tool: AnyDeclarativeTool,
-    args: object,
-  ): AnyToolInvocation | Error {
-    try {
-      return tool.build(args);
-    } catch (e) {
-      if (e instanceof Error) {
-        return e;
-      }
-      return new Error(String(e));
-    }
-  }
-
-  /**
-   * Generates error message for unknown tool. Returns early with skill-specific
-   * message if the name matches a skill, otherwise uses Levenshtein suggestions.
-   */
-  private getToolNotFoundMessage(unknownToolName: string, topN = 3): string {
-    // Check if the unknown tool name matches an available skill name.
-    // This handles the case where the model tries to invoke a skill as a tool
-    // (e.g., Tool: "pdf" instead of Tool: "Skill" with skill: "pdf")
-    const skillTool = this.toolRegistry.getTool(ToolNames.SKILL);
-    if (skillTool instanceof SkillTool) {
-      const availableSkillNames = skillTool.getAvailableSkillNames();
-      if (availableSkillNames.includes(unknownToolName)) {
-        return `"${unknownToolName}" is a skill name, not a tool name. To use this skill, invoke the "${ToolNames.SKILL}" tool with parameter: skill: "${unknownToolName}"`;
-      }
-    }
-
-    // Standard "not found" message with Levenshtein suggestions
-    const suggestion = this.getToolSuggestion(unknownToolName, topN);
-    return `Tool "${unknownToolName}" not found in registry. Tools must use the exact names that are registered.${suggestion}`;
-  }
-
-  /** Suggests similar tool names using Levenshtein distance. */
-  private getToolSuggestion(unknownToolName: string, topN = 3): string {
-    const allToolNames = this.toolRegistry.getAllToolNames();
-
-    const matches = allToolNames.map((toolName) => ({
-      name: toolName,
-      distance: levenshtein.get(unknownToolName, toolName),
-    }));
-
-    matches.sort((a, b) => a.distance - b.distance);
-
-    const topNResults = matches.slice(0, topN);
-
-    if (topNResults.length === 0) {
-      return '';
-    }
-
-    const suggestedNames = topNResults
-      .map((match) => `"${match.name}"`)
-      .join(', ');
-
-    if (topNResults.length > 1) {
-      return ` Did you mean one of: ${suggestedNames}?`;
-    } else {
-      return ` Did you mean ${suggestedNames}?`;
-    }
-  }
-
-  schedule(
-    request: ToolCallRequestInfo | ToolCallRequestInfo[],
-    signal: AbortSignal,
-  ): Promise<void> {
-    if (this.isRunning() || this.isScheduling) {
-      return new Promise((resolve, reject) => {
-        const abortHandler = () => {
-          // Find and remove the request from the queue
-          const index = this.requestQueue.findIndex(
-            (item) => item.request === request,
-          );
-          if (index > -1) {
-            this.requestQueue.splice(index, 1);
-            reject(new Error('Tool call cancelled while in queue.'));
-          }
-        };
-
-        signal.addEventListener('abort', abortHandler, { once: true });
-
-        this.requestQueue.push({
-          request,
-          signal,
-          resolve: () => {
-            signal.removeEventListener('abort', abortHandler);
-            resolve();
-          },
-          reject: (reason?: Error) => {
-            signal.removeEventListener('abort', abortHandler);
-            reject(reason);
-          },
-        });
-      });
-    }
-    return this._schedule(request, signal);
-  }
-
-  private async _schedule(
-    request: ToolCallRequestInfo | ToolCallRequestInfo[],
-    signal: AbortSignal,
-  ): Promise<void> {
-    this.isScheduling = true;
-    try {
-      if (this.isRunning()) {
-        throw new Error(
-          'Cannot schedule new tool calls while other tool calls are actively running (executing or awaiting approval).',
-        );
-      }
-      const requestsToProcess = Array.isArray(request) ? request : [request];
-
-      const newToolCalls: ToolCall[] = requestsToProcess.map(
-        (reqInfo): ToolCall => {
-          // Check if the tool is excluded due to permissions/environment restrictions
-          // This check should happen before registry lookup to provide a clear permission error
-          const excludeTools = this.config.getExcludeTools?.() ?? undefined;
-          if (excludeTools && excludeTools.length > 0) {
-            const normalizedToolName = reqInfo.name.toLowerCase().trim();
-            const excludedMatch = excludeTools.find(
-              (excludedTool) =>
-                excludedTool.toLowerCase().trim() === normalizedToolName,
-            );
-
-            if (excludedMatch) {
-              // The tool exists but is excluded - return permission error directly
-              const permissionErrorMessage = `Qwen Code requires permission to use ${excludedMatch}, but that permission was declined.`;
-              return {
-                status: 'error',
-                request: reqInfo,
-                response: createErrorResponse(
-                  reqInfo,
-                  new Error(permissionErrorMessage),
-                  ToolErrorType.EXECUTION_DENIED,
-                ),
-                durationMs: 0,
-              };
-            }
-          }
-
-          const toolInstance = this.toolRegistry.getTool(reqInfo.name);
-          if (!toolInstance) {
-            // Tool is not in registry and not excluded - likely hallucinated or typo
-            const errorMessage = this.getToolNotFoundMessage(reqInfo.name);
-            return {
-              status: 'error',
-              request: reqInfo,
-              response: createErrorResponse(
-                reqInfo,
-                new Error(errorMessage),
-                ToolErrorType.TOOL_NOT_REGISTERED,
-              ),
-              durationMs: 0,
-            };
-          }
-
-          const invocationOrError = this.buildInvocation(
-            toolInstance,
-            reqInfo.args,
-          );
-          if (invocationOrError instanceof Error) {
-            const error = reqInfo.wasOutputTruncated
-              ? new Error(
-                  `${invocationOrError.message} ${TRUNCATION_PARAM_GUIDANCE}`,
-                )
-              : invocationOrError;
-            return {
-              status: 'error',
-              request: reqInfo,
-              tool: toolInstance,
-              response: createErrorResponse(
-                reqInfo,
-                error,
-                ToolErrorType.INVALID_TOOL_PARAMS,
-              ),
-              durationMs: 0,
-            };
-          }
-
-          // Reject file-modifying calls when truncated to prevent
-          // writing incomplete content.
-          if (reqInfo.wasOutputTruncated && toolInstance.kind === Kind.Edit) {
-            const truncationError = new Error(TRUNCATION_EDIT_REJECTION);
-            return {
-              status: 'error',
-              request: reqInfo,
-              tool: toolInstance,
-              response: createErrorResponse(
-                reqInfo,
-                truncationError,
-                ToolErrorType.OUTPUT_TRUNCATED,
-              ),
-              durationMs: 0,
-            };
-          }
-
-          return {
-            status: 'validating',
-            request: reqInfo,
-            tool: toolInstance,
-            invocation: invocationOrError,
-            startTime: Date.now(),
-          };
-        },
-      );
-
-      this.toolCalls = this.toolCalls.concat(newToolCalls);
-      this.notifyToolCallsUpdate();
-
-      for (const toolCall of newToolCalls) {
-        if (toolCall.status !== 'validating') {
-          continue;
-        }
-
-        const { request: reqInfo, invocation } = toolCall;
-
-        try {
-          if (signal.aborted) {
-            this.setStatusInternal(
-              reqInfo.callId,
-              'cancelled',
-              'Tool call cancelled by user.',
-            );
-            continue;
-          }
-
-          const confirmationDetails =
-            await invocation.shouldConfirmExecute(signal);
-
-          if (!confirmationDetails) {
-            this.setToolCallOutcome(
-              reqInfo.callId,
-              ToolConfirmationOutcome.ProceedAlways,
-            );
-            this.setStatusInternal(reqInfo.callId, 'scheduled');
-            continue;
-          }
-
-          const allowedTools = this.config.getAllowedTools() || [];
-          const isPlanMode =
-            this.config.getApprovalMode() === ApprovalMode.PLAN;
-          const isExitPlanModeTool = reqInfo.name === 'exit_plan_mode';
-
-          // ask_user_question needs the confirmation flow even in plan mode
-          // so the user can actually answer the questions
-          const isAskUserQuestionTool =
-            confirmationDetails &&
-            confirmationDetails.type === 'ask_user_question';
-
-          if (isPlanMode && !isExitPlanModeTool && !isAskUserQuestionTool) {
-            if (confirmationDetails) {
-              this.setStatusInternal(reqInfo.callId, 'error', {
-                callId: reqInfo.callId,
-                responseParts: convertToFunctionResponse(
-                  reqInfo.name,
-                  reqInfo.callId,
-                  getPlanModeSystemReminder(),
-                ),
-                resultDisplay: 'Plan mode blocked a non-read-only tool call.',
-                error: undefined,
-                errorType: undefined,
-              });
-            } else {
-              this.setStatusInternal(reqInfo.callId, 'scheduled');
-            }
-          } else if (
-            (this.config.getApprovalMode() === ApprovalMode.YOLO ||
-              doesToolInvocationMatch(
-                toolCall.tool,
-                invocation,
-                allowedTools,
-              )) &&
-            // Even in YOLO mode, ask_user_question tool requires user confirmation to ensure the user always has a chance to respond to questions
-            confirmationDetails.type !== 'ask_user_question'
-          ) {
-            this.setToolCallOutcome(
-              reqInfo.callId,
-              ToolConfirmationOutcome.ProceedAlways,
-            );
-            this.setStatusInternal(reqInfo.callId, 'scheduled');
-          } else {
-            /**
-             * In non-interactive mode where no user will respond to approval prompts,
-             * and not running as IDE companion or Zed integration, automatically deny approval.
-             * This is intended to create an explicit denial of the tool call,
-             * rather than silently waiting for approval and hanging forever.
-             */
-            const shouldAutoDeny =
-              !this.config.isInteractive() &&
-              !this.config.getExperimentalZedIntegration() &&
-              this.config.getInputFormat() !== InputFormat.STREAM_JSON;
-
-            if (shouldAutoDeny) {
-              const errorMessage = `Qwen Code requires permission to use "${reqInfo.name}", but that permission was declined.`;
-              this.setStatusInternal(
-                reqInfo.callId,
-                'error',
-                createErrorResponse(
-                  reqInfo,
-                  new Error(errorMessage),
-                  ToolErrorType.EXECUTION_DENIED,
-                ),
-              );
-              continue;
-            }
-
-            // Allow IDE to resolve confirmation
-            if (
-              confirmationDetails.type === 'edit' &&
-              confirmationDetails.ideConfirmation
-            ) {
-              confirmationDetails.ideConfirmation.then((resolution) => {
-                if (resolution.status === 'accepted') {
-                  this.handleConfirmationResponse(
-                    reqInfo.callId,
-                    confirmationDetails.onConfirm,
-                    ToolConfirmationOutcome.ProceedOnce,
-                    signal,
-                  );
-                } else {
-                  this.handleConfirmationResponse(
-                    reqInfo.callId,
-                    confirmationDetails.onConfirm,
-                    ToolConfirmationOutcome.Cancel,
-                    signal,
-                  );
-                }
-              });
-            }
-
-            const originalOnConfirm = confirmationDetails.onConfirm;
-            const wrappedConfirmationDetails: ToolCallConfirmationDetails = {
-              ...confirmationDetails,
-              onConfirm: (
-                outcome: ToolConfirmationOutcome,
-                payload?: ToolConfirmationPayload,
-              ) =>
-                this.handleConfirmationResponse(
-                  reqInfo.callId,
-                  originalOnConfirm,
-                  outcome,
-                  signal,
-                  payload,
-                ),
-            };
-            this.setStatusInternal(
-              reqInfo.callId,
-              'awaiting_approval',
-              wrappedConfirmationDetails,
-            );
-          }
-        } catch (error) {
-          if (signal.aborted) {
-            this.setStatusInternal(
-              reqInfo.callId,
-              'cancelled',
-              'Tool call cancelled by user.',
-            );
-            continue;
-          }
-
-          this.setStatusInternal(
-            reqInfo.callId,
-            'error',
-            createErrorResponse(
-              reqInfo,
-              error instanceof Error ? error : new Error(String(error)),
-              ToolErrorType.UNHANDLED_EXCEPTION,
-            ),
-          );
-        }
-      }
-      await this.attemptExecutionOfScheduledCalls(signal);
-      void this.checkAndNotifyCompletion();
-    } finally {
-      this.isScheduling = false;
-    }
-  }
-
-  async handleConfirmationResponse(
-    callId: string,
-    originalOnConfirm: (
-      outcome: ToolConfirmationOutcome,
-      payload?: ToolConfirmationPayload,
-    ) => Promise<void>,
-    outcome: ToolConfirmationOutcome,
-    signal: AbortSignal,
-    payload?: ToolConfirmationPayload,
-  ): Promise<void> {
-    const toolCall = this.toolCalls.find(
-      (c) => c.request.callId === callId && c.status === 'awaiting_approval',
-    );
-
-    await originalOnConfirm(outcome, payload);
-
-    if (outcome === ToolConfirmationOutcome.ProceedAlways) {
-      await this.autoApproveCompatiblePendingTools(signal, callId);
-    }
-
-    this.setToolCallOutcome(callId, outcome);
-
-    if (outcome === ToolConfirmationOutcome.Cancel || signal.aborted) {
-      // Use custom cancel message from payload if provided, otherwise use default
-      const cancelMessage =
-        payload?.cancelMessage || 'User did not allow tool call';
-      this.setStatusInternal(callId, 'cancelled', cancelMessage);
-    } else if (outcome === ToolConfirmationOutcome.ModifyWithEditor) {
-      const waitingToolCall = toolCall as WaitingToolCall;
-      if (isModifiableDeclarativeTool(waitingToolCall.tool)) {
-        const modifyContext = waitingToolCall.tool.getModifyContext(signal);
-        const editorType = this.getPreferredEditor();
-        if (!editorType) {
-          return;
-        }
-
-        this.setStatusInternal(callId, 'awaiting_approval', {
-          ...waitingToolCall.confirmationDetails,
-          isModifying: true,
-        } as ToolCallConfirmationDetails);
-
-        const { updatedParams, updatedDiff } = await modifyWithEditor<
-          typeof waitingToolCall.request.args
-        >(
-          waitingToolCall.request.args,
-          modifyContext as ModifyContext<typeof waitingToolCall.request.args>,
-          editorType,
-          signal,
-          this.onEditorClose,
-        );
-        this.setArgsInternal(callId, updatedParams);
-        this.setStatusInternal(callId, 'awaiting_approval', {
-          ...waitingToolCall.confirmationDetails,
-          fileDiff: updatedDiff,
-          isModifying: false,
-        } as ToolCallConfirmationDetails);
-      }
-    } else {
-      // If the client provided new content, apply it before scheduling.
-      if (payload?.newContent && toolCall) {
-        await this._applyInlineModify(
-          toolCall as WaitingToolCall,
-          payload,
-          signal,
-        );
-      }
-      this.setStatusInternal(callId, 'scheduled');
-    }
-    await this.attemptExecutionOfScheduledCalls(signal);
-  }
-
-  /**
-   * Applies user-provided content changes to a tool call that is awaiting confirmation.
-   * This method updates the tool's arguments and refreshes the confirmation prompt with a new diff
-   * before the tool is scheduled for execution.
-   * @private
-   */
-  private async _applyInlineModify(
-    toolCall: WaitingToolCall,
-    payload: ToolConfirmationPayload,
-    signal: AbortSignal,
-  ): Promise<void> {
-    if (
-      toolCall.confirmationDetails.type !== 'edit' ||
-      !isModifiableDeclarativeTool(toolCall.tool) ||
-      !payload.newContent
-    ) {
-      return;
-    }
-
-    const modifyContext = toolCall.tool.getModifyContext(signal);
-    const currentContent = await modifyContext.getCurrentContent(
-      toolCall.request.args,
-    );
-
-    const updatedParams = modifyContext.createUpdatedParams(
-      currentContent,
-      payload.newContent,
-      toolCall.request.args,
-    );
-    const updatedDiff = Diff.createPatch(
-      modifyContext.getFilePath(toolCall.request.args),
-      currentContent,
-      payload.newContent,
-      'Current',
-      'Proposed',
-    );
-
-    this.setArgsInternal(toolCall.request.callId, updatedParams);
-    this.setStatusInternal(toolCall.request.callId, 'awaiting_approval', {
-      ...toolCall.confirmationDetails,
-      fileDiff: updatedDiff,
-    });
-  }
-
-  private async attemptExecutionOfScheduledCalls(
-    signal: AbortSignal,
-  ): Promise<void> {
-    const allCallsFinalOrScheduled = this.toolCalls.every(
-      (call) =>
-        call.status === 'scheduled' ||
-        call.status === 'cancelled' ||
-        call.status === 'success' ||
-        call.status === 'error',
-    );
-
-    if (allCallsFinalOrScheduled) {
-      const callsToExecute = this.toolCalls.filter(
-        (call) => call.status === 'scheduled',
-      );
-
-      for (const toolCall of callsToExecute) {
-        await this.executeSingleToolCall(toolCall, signal);
-      }
-    }
-  }
-
-  private async executeSingleToolCall(
-    toolCall: ToolCall,
-    signal: AbortSignal,
-  ): Promise<void> {
-    if (toolCall.status !== 'scheduled') return;
-
-    const scheduledCall = toolCall;
-    const { callId, name: toolName } = scheduledCall.request;
-    const invocation = scheduledCall.invocation;
-    this.setStatusInternal(callId, 'executing');
-
-    const liveOutputCallback = scheduledCall.tool.canUpdateOutput
-      ? (outputChunk: ToolResultDisplay) => {
-          if (this.outputUpdateHandler) {
-            this.outputUpdateHandler(callId, outputChunk);
-          }
-          this.toolCalls = this.toolCalls.map((tc) =>
-            tc.request.callId === callId && tc.status === 'executing'
-              ? { ...tc, liveOutput: outputChunk }
-              : tc,
-          );
-          this.notifyToolCallsUpdate();
-        }
-      : undefined;
-
-    const shellExecutionConfig = this.config.getShellExecutionConfig();
-
-    // TODO: Refactor to remove special casing for ShellToolInvocation.
-    // Introduce a generic callbacks object for the execute method to handle
-    // things like `onPid` and `onLiveOutput`. This will make the scheduler
-    // agnostic to the invocation type.
-    let promise: Promise<ToolResult>;
-    if (invocation instanceof ShellToolInvocation) {
-      const setPidCallback = (pid: number) => {
-        this.toolCalls = this.toolCalls.map((tc) =>
-          tc.request.callId === callId && tc.status === 'executing'
-            ? { ...tc, pid }
-            : tc,
-        );
-        this.notifyToolCallsUpdate();
-      };
-      promise = invocation.execute(
-        signal,
-        liveOutputCallback,
-        shellExecutionConfig,
-        setPidCallback,
-      );
-    } else {
-      promise = invocation.execute(
-        signal,
-        liveOutputCallback,
-        shellExecutionConfig,
-      );
-    }
-
-    try {
-      const toolResult: ToolResult = await promise;
-      if (signal.aborted) {
-        this.setStatusInternal(
-          callId,
-          'cancelled',
-          'User cancelled tool execution.',
-        );
-        return;
-      }
-
-      if (toolResult.error === undefined) {
-        let content = toolResult.llmContent;
-        let outputFile: string | undefined = undefined;
-        const contentLength =
-          typeof content === 'string' ? content.length : undefined;
-        if (
-          typeof content === 'string' &&
-          toolName === ShellTool.Name &&
-          this.config.getEnableToolOutputTruncation() &&
-          this.config.getTruncateToolOutputThreshold() > 0 &&
-          this.config.getTruncateToolOutputLines() > 0
-        ) {
-          const originalContentLength = content.length;
-          const threshold = this.config.getTruncateToolOutputThreshold();
-          const lines = this.config.getTruncateToolOutputLines();
-          const truncatedResult = await truncateAndSaveToFile(
-            content,
-            callId,
-            this.config.storage.getProjectTempDir(),
-            threshold,
-            lines,
-          );
-          content = truncatedResult.content;
-          outputFile = truncatedResult.outputFile;
-
-          if (outputFile) {
-            logToolOutputTruncated(
-              this.config,
-              new ToolOutputTruncatedEvent(scheduledCall.request.prompt_id, {
-                toolName,
-                originalContentLength,
-                truncatedContentLength: content.length,
-                threshold,
-                lines,
-              }),
-            );
-          }
-        }
-
-        const response = convertToFunctionResponse(toolName, callId, content);
-        const successResponse: ToolCallResponseInfo = {
-          callId,
-          responseParts: response,
-          resultDisplay: toolResult.returnDisplay,
-          error: undefined,
-          errorType: undefined,
-          outputFile,
-          contentLength,
-        };
-        this.setStatusInternal(callId, 'success', successResponse);
-      } else {
-        // It is a failure
-        const error = new Error(toolResult.error.message);
-        const errorResponse = createErrorResponse(
-          scheduledCall.request,
-          error,
-          toolResult.error.type,
-        );
-        this.setStatusInternal(callId, 'error', errorResponse);
-      }
-    } catch (executionError: unknown) {
-      if (signal.aborted) {
-        this.setStatusInternal(
-          callId,
-          'cancelled',
-          'User cancelled tool execution.',
-        );
-      } else {
-        this.setStatusInternal(
-          callId,
-          'error',
-          createErrorResponse(
-            scheduledCall.request,
-            executionError instanceof Error
-              ? executionError
-              : new Error(String(executionError)),
-            ToolErrorType.UNHANDLED_EXCEPTION,
-          ),
-        );
-      }
-    }
-  }
-
-  private async checkAndNotifyCompletion(): Promise<void> {
-    const allCallsAreTerminal = this.toolCalls.every(
-      (call) =>
-        call.status === 'success' ||
-        call.status === 'error' ||
-        call.status === 'cancelled',
-    );
-
-    if (this.toolCalls.length > 0 && allCallsAreTerminal) {
-      const completedCalls = [...this.toolCalls] as CompletedToolCall[];
-      this.toolCalls = [];
-
-      for (const call of completedCalls) {
-        logToolCall(this.config, new ToolCallEvent(call));
-      }
-
-      // Record tool results before notifying completion
-      this.recordToolResults(completedCalls);
-
-      if (this.onAllToolCallsComplete) {
-        this.isFinalizingToolCalls = true;
-        await this.onAllToolCallsComplete(completedCalls);
-        this.isFinalizingToolCalls = false;
-      }
-      this.notifyToolCallsUpdate();
-      // After completion, process the next item in the queue.
-      if (this.requestQueue.length > 0) {
-        const next = this.requestQueue.shift()!;
-        this._schedule(next.request, next.signal)
-          .then(next.resolve)
-          .catch(next.reject);
-      }
-    }
-  }
-
-  /**
-   * Records tool results to the chat recording service.
-   * This captures both the raw Content (for API reconstruction) and
-   * enriched metadata (for UI recovery).
-   */
-  private recordToolResults(completedCalls: CompletedToolCall[]): void {
-    if (!this.chatRecordingService) return;
-
-    // Collect all response parts from completed calls
-    const responseParts: Part[] = completedCalls.flatMap(
-      (call) => call.response.responseParts,
-    );
-
-    if (responseParts.length === 0) return;
-
-    // Record each tool result individually
-    for (const call of completedCalls) {
-      this.chatRecordingService.recordToolResult(call.response.responseParts, {
-        callId: call.request.callId,
-        status: call.status,
-        resultDisplay: call.response.resultDisplay,
-        error: call.response.error,
-        errorType: call.response.errorType,
-      });
-    }
-  }
-
-  private notifyToolCallsUpdate(): void {
-    if (this.onToolCallsUpdate) {
-      this.onToolCallsUpdate([...this.toolCalls]);
-    }
-  }
-
-  private setToolCallOutcome(callId: string, outcome: ToolConfirmationOutcome) {
-    this.toolCalls = this.toolCalls.map((call) => {
-      if (call.request.callId !== callId) return call;
-      return {
-        ...call,
-        outcome,
-      };
-    });
-  }
-
-  private async autoApproveCompatiblePendingTools(
-    signal: AbortSignal,
-    triggeringCallId: string,
-  ): Promise<void> {
-    const pendingTools = this.toolCalls.filter(
-      (call) =>
-        call.status === 'awaiting_approval' &&
-        call.request.callId !== triggeringCallId,
-    ) as WaitingToolCall[];
-
-    for (const pendingTool of pendingTools) {
-      try {
-        const stillNeedsConfirmation =
-          await pendingTool.invocation.shouldConfirmExecute(signal);
-
-        if (!stillNeedsConfirmation) {
-          this.setToolCallOutcome(
-            pendingTool.request.callId,
-            ToolConfirmationOutcome.ProceedAlways,
-          );
-          this.setStatusInternal(pendingTool.request.callId, 'scheduled');
-        }
-      } catch (error) {
-        debugLogger.error(
-          `Error checking confirmation for tool ${pendingTool.request.callId}:`,
-          error,
-        );
-      }
-    }
-  }
-}