@qwen-code/qwen-code 0.21.4 → 0.21.5

package/chunks/{chunk-JDJ7SC4E.js → chunk-ZPGMDT4S.js}

@@ -8,17 +8,18 @@ import {
 } from "./chunk-E4WHKETF.js";
 import {
   STRUCTURED_OUTPUT_REDACTED_ARGS
-} from "./chunk-UEJESCS7.js";
+} from "./chunk-ZPPP6VCL.js";
 import {
   BaseDeclarativeTool,
   BaseToolInvocation,
   SchemaValidator,
+  StructuredToolError,
   ToolDisplayNames,
   ToolNames
-} from "./chunk-CFDR3GNL.js";
+} from "./chunk-D7D7RXIJ.js";
 import {
   DEFAULT_QWEN_MODEL
-} from "./chunk-TXZDRD36.js";
+} from "./chunk-XD2PNH3K.js";
 import {
   estimateTextTokens,
   generateLegacyMcpToolName,
@@ -52,8 +53,9 @@ import {
   recordModelSlashCommand,
   recordSubagentExecutionMetrics,
   recordTokenUsageMetrics,
-  recordToolCallMetrics
-} from "./chunk-O2ZYHG33.js";
+  recordToolCallMetrics,
+  recordToolExecutionMetrics
+} from "./chunk-5L6CQ4ZU.js";
 import {
   require_src,
   safeJsonStringify
@@ -102,7 +104,7 @@ import {
   EVENT_WORKFLOW_KEYWORD,
   EVENT_WORKFLOW_RUN,
   SERVICE_NAME
-} from "./chunk-G7XXKQYS.js";
+} from "./chunk-LKRMNRSN.js";
 import {
   Storage,
   createDebugLogger,
@@ -11224,12 +11226,14 @@ var QwenLogger = class _QwenLogger {
       `tool_call#${event.function_name}`,
       {
         properties: {
+          call_id: event.call_id,
           prompt_id: event.prompt_id,
           response_id: event.response_id,
           tool_name: event.function_name,
-          permission: event.decision,
           status: event.status,
+          execution_status: event.execution_status,
           tool_type: event.tool_type,
+          permission: event.decision,
           success: event.success ? 1 : 0,
           duration_ms: event.duration_ms,
           error_type: event.error_type,
@@ -12718,6 +12722,32 @@ function recordUiTelemetryEventToChat(config, uiEvent) {
   config.getChatRecordingService()?.recordUiTelemetryEvent(uiEvent);
 }
 __name(recordUiTelemetryEventToChat, "recordUiTelemetryEventToChat");
+function normalizeToolCallEvent(event) {
+  const functionName = event.function_name ?? "";
+  const normalized = {
+    ...event,
+    function_name: functionName.trim().length > 0 ? functionName : "unknown_tool",
+    success: event.status === "success",
+    execution_status: event.execution_status ?? "unknown"
+  };
+  if (event.status === "error") {
+    normalized.error_type = event.error_type?.trim() || "unknown" /* UNKNOWN */;
+  } else {
+    delete normalized.error;
+    delete normalized.error_type;
+  }
+  return normalized;
+}
+__name(normalizeToolCallEvent, "normalizeToolCallEvent");
+var debugLogger5 = createDebugLogger("TELEMETRY_SINK");
+function runToolTelemetrySink(sink) {
+  try {
+    sink();
+  } catch (e) {
+    debugLogger5.debug("Telemetry sink failed (best-effort):", e);
+  }
+}
+__name(runToolTelemetrySink, "runToolTelemetrySink");
 function logStartSession(config, event) {
   QwenLogger.getInstance(config)?.logStartSessionEvent(event);
   if (!isTelemetrySdkInitialized()) return;
@@ -12796,17 +12826,6 @@ function logUserRetry(config, event) {
   logger.emit(logRecord);
 }
 __name(logUserRetry, "logUserRetry");
-function normalizeToolCallEvent(event) {
-  const isError = event.status === "error";
-  return {
-    ...event,
-    function_name: event.function_name.trim().length > 0 ? event.function_name : "unknown_tool",
-    success: event.status === "success",
-    error: isError ? event.error : void 0,
-    error_type: isError ? event.error_type?.trim() ? event.error_type : "unknown" /* UNKNOWN */ : void 0
-  };
-}
-__name(normalizeToolCallEvent, "normalizeToolCallEvent");
 function logToolCall(config, event) {
   const normalizedEvent = normalizeToolCallEvent(event);
   const uiEvent = {
@@ -12814,37 +12833,53 @@ function logToolCall(config, event) {
     "event.name": EVENT_TOOL_CALL,
     "event.timestamp": (/* @__PURE__ */ new Date()).toISOString()
   };
-  uiTelemetryService.addEvent(uiEvent, config.getSessionId());
-  if (!isInternalPromptId(normalizedEvent.prompt_id)) {
-    recordUiTelemetryEventToChat(config, uiEvent);
-  }
-  QwenLogger.getInstance(config)?.logToolCallEvent(normalizedEvent);
+  runToolTelemetrySink(() => {
+    uiTelemetryService.addEvent(uiEvent, config.getSessionId());
+  });
+  runToolTelemetrySink(() => {
+    if (!isInternalPromptId(normalizedEvent.prompt_id)) {
+      recordUiTelemetryEventToChat(config, uiEvent);
+    }
+  });
+  runToolTelemetrySink(() => {
+    QwenLogger.getInstance(config)?.logToolCallEvent(normalizedEvent);
+  });
   if (!isTelemetrySdkInitialized()) return;
-  const attributes = {
-    ...getCommonAttributes(config),
-    ...normalizedEvent,
-    "event.name": EVENT_TOOL_CALL,
-    "event.timestamp": (/* @__PURE__ */ new Date()).toISOString(),
-    function_args: safeJsonStringify(normalizedEvent.function_args, 2)
-  };
-  if (normalizedEvent.error) {
-    attributes["error.message"] = normalizedEvent.error;
-  }
-  if (normalizedEvent.error_type) {
-    attributes["error.type"] = normalizedEvent.error_type;
-  }
-  const logger = import_api_logs.logs.getLogger(SERVICE_NAME);
-  const logRecord = {
-    body: `Tool call: ${normalizedEvent.function_name}${normalizedEvent.decision ? `. Decision: ${normalizedEvent.decision}` : ""}. Success: ${normalizedEvent.success}. Duration: ${normalizedEvent.duration_ms}ms.`,
-    attributes
-  };
-  logger.emit(logRecord);
-  recordToolCallMetrics(config, normalizedEvent.duration_ms, {
-    function_name: normalizedEvent.function_name,
-    status: normalizedEvent.status,
-    success: normalizedEvent.success,
-    decision: normalizedEvent.decision,
-    tool_type: normalizedEvent.tool_type
+  runToolTelemetrySink(() => {
+    const attributes = {
+      ...getCommonAttributes(config),
+      ...normalizedEvent,
+      "event.name": EVENT_TOOL_CALL,
+      "event.timestamp": (/* @__PURE__ */ new Date()).toISOString(),
+      function_args: safeJsonStringify(normalizedEvent.function_args, 2)
+    };
+    if (normalizedEvent.error) {
+      attributes["error.message"] = normalizedEvent.error;
+    }
+    if (normalizedEvent.error_type) {
+      attributes["error.type"] = normalizedEvent.error_type;
+    }
+    const logger = import_api_logs.logs.getLogger(SERVICE_NAME);
+    const logRecord = {
+      body: `Tool call: ${normalizedEvent.function_name}${normalizedEvent.decision ? `. Decision: ${normalizedEvent.decision}` : ""}. Success: ${normalizedEvent.success}. Duration: ${normalizedEvent.duration_ms}ms.`,
+      attributes
+    };
+    logger.emit(logRecord);
+  });
+  runToolTelemetrySink(() => {
+    recordToolCallMetrics(config, normalizedEvent.duration_ms, {
+      function_name: normalizedEvent.function_name,
+      status: normalizedEvent.status,
+      success: normalizedEvent.success,
+      decision: normalizedEvent.decision,
+      tool_type: normalizedEvent.tool_type
+    });
+  });
+  runToolTelemetrySink(() => {
+    recordToolExecutionMetrics(config, {
+      execution_status: normalizedEvent.execution_status,
+      tool_type: normalizedEvent.tool_type
+    });
   });
 }
 __name(logToolCall, "logToolCall");
@@ -13749,7 +13784,7 @@ init_esbuild_shims();
 import * as fs6 from "node:fs/promises";
 import * as path7 from "node:path";
 import * as crypto from "node:crypto";
-var debugLogger5 = createDebugLogger("TRUNCATION");
+var debugLogger6 = createDebugLogger("TRUNCATION");
 var PREVIEW_SIZE_CHARS = 2e3;
 var MAX_FILE_SIZE_BYTES = 50 * 1024 * 1024;
 var MAX_SESSION_BYTES = 500 * 1024 * 1024;
@@ -13836,7 +13871,7 @@ ${truncatedContent}`;
       outputFile
     };
   } catch (error) {
-    debugLogger5.warn(
+    debugLogger6.warn(
       `Failed to save truncated output to ${outputFile}:`,
       error
     );
@@ -13947,7 +13982,7 @@ __name(normalizeToolResultCallId, "normalizeToolResultCallId");
 async function persistAndTruncateToolResult(callId, toolName, content, config) {
   const byteSize = Buffer.byteLength(content, "utf-8");
   if (byteSize > MAX_FILE_SIZE_BYTES) {
-    debugLogger5.warn(
+    debugLogger6.warn(
       `Tool result for ${toolName} exceeds ${MAX_FILE_SIZE_BYTES} bytes (${byteSize}), skipping disk persistence`
     );
     return {
@@ -13957,7 +13992,7 @@ async function persistAndTruncateToolResult(callId, toolName, content, config) {
   }
   const budgetUsed = config.getToolResultBytesWritten();
   if (budgetUsed + byteSize > MAX_SESSION_BYTES) {
-    debugLogger5.warn(
+    debugLogger6.warn(
       `Session tool result budget exhausted (${budgetUsed} + ${byteSize} > ${MAX_SESSION_BYTES}), skipping disk persistence`
     );
     return {
@@ -13968,7 +14003,7 @@ async function persistAndTruncateToolResult(callId, toolName, content, config) {
   config.trackToolResultBytes(byteSize);
   const safeCallId = normalizeToolResultCallId(callId);
   if (!safeCallId) {
-    debugLogger5.warn(
+    debugLogger6.warn(
       `Invalid callId for disk persistence: ${JSON.stringify(callId)}`
     );
     config.trackToolResultBytes(-byteSize);
@@ -13993,7 +14028,7 @@ async function persistAndTruncateToolResult(callId, toolName, content, config) {
       bytesWritten: byteSize
     };
   } catch (error) {
-    debugLogger5.warn("Failed to persist tool result:", error);
+    debugLogger6.warn("Failed to persist tool result:", error);
     try {
       const fallback = await truncateAndSaveToFile(
         content,
@@ -14013,7 +14048,7 @@ async function persistAndTruncateToolResult(callId, toolName, content, config) {
       return { content: fallback.content, bytesWritten: 0 };
     } catch (fallbackError) {
       config.trackToolResultBytes(-byteSize);
-      debugLogger5.warn("Fallback truncation also failed:", fallbackError);
+      debugLogger6.warn("Fallback truncation also failed:", fallbackError);
       return {
         content: buildStub(content, byteSize, "(disk persistence unavailable)"),
         bytesWritten: 0
@@ -14206,7 +14241,7 @@ function collectText(parts) {
 __name(collectText, "collectText");
 
 // packages/core/src/tools/mcp-tool.ts
-var debugLogger6 = createDebugLogger("MCP_TOOL");
+var debugLogger7 = createDebugLogger("MCP_TOOL");
 var MCP_CONNECTION_ERROR_PATTERNS = [
   /ECONNREFUSED/i,
   /ENOTFOUND/i,
@@ -14217,6 +14252,51 @@ var MCP_CONNECTION_ERROR_PATTERNS = [
   /disconnected/i,
   /transport closed/i
 ];
+var MCP_REQUEST_TIMEOUT_CODE = -32001;
+function isMcpRequestTimeout(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === MCP_REQUEST_TIMEOUT_CODE;
+}
+__name(isMcpRequestTimeout, "isMcpRequestTimeout");
+function isExecutionTimeoutFailure(error, serverName, signal) {
+  if (signal.aborted) return false;
+  if (!isMcpRequestTimeout(error)) return false;
+  const statuses = getAllMCPServerStatuses();
+  return !(statuses.has(serverName) && statuses.get(serverName) === "disconnected" /* DISCONNECTED */);
+}
+__name(isExecutionTimeoutFailure, "isExecutionTimeoutFailure");
+var PARENT_ABORT_OUTCOME = Symbol("parent_abort_outcome");
+function createToolCallAbortError() {
+  return Object.assign(new Error("Tool call aborted"), { name: "AbortError" });
+}
+__name(createToolCallAbortError, "createToolCallAbortError");
+function isParentAbortOutcome(value) {
+  return typeof value === "object" && value !== null && PARENT_ABORT_OUTCOME in value;
+}
+__name(isParentAbortOutcome, "isParentAbortOutcome");
+function createParentAbortRace(signal, forwardAbort) {
+  let onAbort;
+  const promise = new Promise((resolve) => {
+    onAbort = /* @__PURE__ */ __name(() => {
+      const reason = createToolCallAbortError();
+      resolve({ [PARENT_ABORT_OUTCOME]: true, reason });
+      forwardAbort?.(reason);
+    }, "onAbort");
+    if (signal.aborted) {
+      onAbort();
+    } else {
+      signal.addEventListener("abort", onAbort, { once: true });
+    }
+  });
+  return {
+    promise,
+    dispose: /* @__PURE__ */ __name(() => {
+      if (onAbort) {
+        signal.removeEventListener("abort", onAbort);
+      }
+    }, "dispose")
+  };
+}
+__name(createParentAbortRace, "createParentAbortRace");
 var DiscoveredMCPToolInvocation = class _DiscoveredMCPToolInvocation extends BaseToolInvocation {
   constructor(mcpTool, serverName, serverToolName, displayName, registeredToolName, permissionAliases, trust, params = {}, cliConfig, mcpClient, mcpTimeout, mcpToolIdleTimeoutMs, annotations, allowInvocationContext = false, retryCount = 0) {
     super(params);
@@ -14239,6 +14319,7 @@ var DiscoveredMCPToolInvocation = class _DiscoveredMCPToolInvocation extends Bas
     __name(this, "DiscoveredMCPToolInvocation");
   }
   static MAX_RECONNECT_RETRIES = 3;
+  static UNSAFE_REPLAY_ERROR_MESSAGE = "MCP tool execution may have completed before the connection failed. Automatic replay was skipped because the call could not be verified as safe to replay. Do not retry automatically; verify the outcome before trying again.";
   /**
    * MCP tool default permission based on trust:
    * - trust: true in a trusted folder → 'allow' (server explicitly trusted by user config)
@@ -14286,33 +14367,42 @@ var DiscoveredMCPToolInvocation = class _DiscoveredMCPToolInvocation extends Bas
       return null;
     }
     try {
-      debugLogger6.info(
+      debugLogger7.info(
         `Attempting to reconnect MCP server '${this.serverName}'...`
       );
       const toolRegistry = this.cliConfig.getToolRegistry();
       await toolRegistry.discoverToolsForServer(this.serverName);
       const newTool = await toolRegistry.ensureTool(this.registeredToolName);
       if (newTool instanceof DiscoveredMCPTool) {
-        debugLogger6.info(
+        debugLogger7.info(
           `Successfully reconnected to MCP server '${this.serverName}'`
         );
         return newTool;
       }
       return null;
     } catch (error) {
-      debugLogger6.error(
+      debugLogger7.error(
         `Failed to reconnect MCP server '${this.serverName}': ${error}`
       );
       return null;
     }
   }
   async handleReconnectOnError(error, signal, updateOutput) {
-    debugLogger6.error(`MCP server error '${this.serverName}': ${error}`);
+    debugLogger7.error(`MCP server error '${this.serverName}': ${error}`);
+    if (signal.aborted) {
+      throw error;
+    }
     if (!this.shouldAttemptReconnect(error)) {
       throw error;
     }
+    if (!this.cliConfig) {
+      throw error;
+    }
+    if (!this.canSafelyReplay()) {
+      throw new Error(_DiscoveredMCPToolInvocation.UNSAFE_REPLAY_ERROR_MESSAGE);
+    }
     if (this.retryCount < _DiscoveredMCPToolInvocation.MAX_RECONNECT_RETRIES) {
-      debugLogger6.info(
+      debugLogger7.info(
         `Reconnection attempt ${this.retryCount + 1}/${_DiscoveredMCPToolInvocation.MAX_RECONNECT_RETRIES} for MCP server '${this.serverName}'`
       );
       const newTool = await this.attemptReconnect();
@@ -14324,25 +14414,39 @@ var DiscoveredMCPToolInvocation = class _DiscoveredMCPToolInvocation extends Bas
           this.displayName,
           newTool.name,
           newTool.permissionAliases,
-          this.trust,
+          newTool.trust,
           this.params,
           this.cliConfig,
           newTool["mcpClient"],
           this.mcpTimeout,
           this.mcpToolIdleTimeoutMs,
-          this.annotations,
+          newTool.annotations,
           newTool["allowInvocationContext"] === true,
           this.retryCount + 1
         );
+        if (!newInvocation.canSafelyReplay()) {
+          throw new Error(
+            _DiscoveredMCPToolInvocation.UNSAFE_REPLAY_ERROR_MESSAGE
+          );
+        }
         return newInvocation.execute(signal, updateOutput);
       }
     } else if (this.retryCount >= _DiscoveredMCPToolInvocation.MAX_RECONNECT_RETRIES) {
-      debugLogger6.error(
+      debugLogger7.error(
         `Max reconnection attempts (${_DiscoveredMCPToolInvocation.MAX_RECONNECT_RETRIES}) reached for MCP server '${this.serverName}'`
       );
     }
     throw error;
   }
+  canSafelyReplay() {
+    if (this.trust !== true || this.cliConfig?.isTrustedFolder() !== true || !this.annotations) {
+      return false;
+    }
+    if (this.annotations.readOnlyHint === true && (this.annotations.destructiveHint === true || this.annotations.idempotentHint === false)) {
+      return false;
+    }
+    return this.annotations.idempotentHint === true || this.annotations.readOnlyHint === true;
+  }
   shouldAttemptReconnect(error) {
     if (isAbortError(error)) {
       return false;
@@ -14368,10 +14472,18 @@ var DiscoveredMCPToolInvocation = class _DiscoveredMCPToolInvocation extends Bas
    * MCP tool calls (e.g., browser automation).
    */
   async executeWithDirectClient(signal, updateOutput) {
+    if (signal.aborted) {
+      throw createToolCallAbortError();
+    }
     const idleTimeoutController = new AbortController();
+    const parentAbortController = new AbortController();
+    const parentAbortRace = createParentAbortRace(signal, (reason) => {
+      parentAbortController.abort(reason);
+    });
     let idleTimeoutId;
+    let idleTimeoutWon = false;
     const combinedSignal = AbortSignal.any([
-      signal,
+      parentAbortController.signal,
       idleTimeoutController.signal
     ]);
     const resetIdleTimeout = /* @__PURE__ */ __name(() => {
@@ -14380,6 +14492,10 @@ var DiscoveredMCPToolInvocation = class _DiscoveredMCPToolInvocation extends Bas
       }
       if (this.mcpToolIdleTimeoutMs && this.mcpToolIdleTimeoutMs > 0) {
         const timer = setTimeout(() => {
+          if (signal.aborted) {
+            return;
+          }
+          idleTimeoutWon = true;
           const error = new Error(
             `MCP tool '${this.serverToolName}' on server '${this.serverName}' did not respond within ${this.mcpToolIdleTimeoutMs}ms idle timeout`
           );
@@ -14393,7 +14509,7 @@ var DiscoveredMCPToolInvocation = class _DiscoveredMCPToolInvocation extends Bas
     try {
       resetIdleTimeout();
       const invocationContext = this.allowInvocationContext ? getInvocationContext() : void 0;
-      const callToolResult = await this.mcpClient.callTool(
+      const callPromise = this.mcpClient.callTool(
         {
           name: this.serverToolName,
           arguments: this.params,
@@ -14421,6 +14537,14 @@ var DiscoveredMCPToolInvocation = class _DiscoveredMCPToolInvocation extends Bas
           signal: combinedSignal
         }
       );
+      const outcome = await Promise.race([
+        callPromise,
+        parentAbortRace.promise
+      ]);
+      if (isParentAbortOutcome(outcome)) {
+        throw outcome.reason;
+      }
+      const callToolResult = outcome;
       const rawResponseParts = wrapMcpCallToolResultAsParts(
         this.serverToolName,
         callToolResult
@@ -14442,11 +14566,18 @@ var DiscoveredMCPToolInvocation = class _DiscoveredMCPToolInvocation extends Bas
         persistedOutputFiles: truncated.persistedOutputFiles
       };
     } catch (error) {
+      if (idleTimeoutWon || isExecutionTimeoutFailure(error, this.serverName, signal)) {
+        throw new StructuredToolError(
+          getErrorMessage(error),
+          "execution_timeout" /* EXECUTION_TIMEOUT */
+        );
+      }
       return this.handleReconnectOnError(error, signal, updateOutput);
     } finally {
       if (idleTimeoutId) {
         clearTimeout(idleTimeoutId);
       }
+      parentAbortRace.dispose();
     }
   }
   /**
@@ -14454,38 +14585,26 @@ var DiscoveredMCPToolInvocation = class _DiscoveredMCPToolInvocation extends Bas
    * This path does NOT support progress notifications.
    */
   async executeWithCallableTool(signal) {
+    if (signal.aborted) {
+      throw createToolCallAbortError();
+    }
     const functionCalls = [
       {
         name: this.serverToolName,
         args: this.params
       }
     ];
+    const parentAbortRace = createParentAbortRace(signal);
     try {
-      const rawResponseParts = await new Promise((resolve, reject) => {
-        if (signal.aborted) {
-          const error = new Error("Tool call aborted");
-          error.name = "AbortError";
-          reject(error);
-          return;
-        }
-        const onAbort = /* @__PURE__ */ __name(() => {
-          cleanup();
-          const error = new Error("Tool call aborted");
-          error.name = "AbortError";
-          reject(error);
-        }, "onAbort");
-        const cleanup = /* @__PURE__ */ __name(() => {
-          signal.removeEventListener("abort", onAbort);
-        }, "cleanup");
-        signal.addEventListener("abort", onAbort, { once: true });
-        this.mcpTool.callTool(functionCalls).then((res) => {
-          cleanup();
-          resolve(res);
-        }).catch((err) => {
-          cleanup();
-          reject(err);
-        });
-      });
+      const callPromise = this.mcpTool.callTool(functionCalls);
+      const outcome = await Promise.race([
+        callPromise,
+        parentAbortRace.promise
+      ]);
+      if (isParentAbortOutcome(outcome)) {
+        throw outcome.reason;
+      }
+      const rawResponseParts = outcome;
       if (this.isMCPToolError(rawResponseParts)) {
         return await this.buildMcpToolError(rawResponseParts, functionCalls[0]);
       }
@@ -14500,7 +14619,15 @@ var DiscoveredMCPToolInvocation = class _DiscoveredMCPToolInvocation extends Bas
         persistedOutputFiles: truncated.persistedOutputFiles
       };
     } catch (error) {
+      if (isExecutionTimeoutFailure(error, this.serverName, signal)) {
+        throw new StructuredToolError(
+          getErrorMessage(error),
+          "execution_timeout" /* EXECUTION_TIMEOUT */
+        );
+      }
       return this.handleReconnectOnError(error, signal);
+    } finally {
+      parentAbortRace.dispose();
     }
   }
   async buildMcpToolError(rawResponseParts, functionCall) {
@@ -14931,10 +15058,12 @@ var ToolCallEvent = class {
   }
   "event.name";
   "event.timestamp";
+  call_id;
   function_name;
   function_args;
   duration_ms;
   status;
+  execution_status;
   success;
   // Keep for backward compatibility
   decision;
@@ -14950,10 +15079,12 @@ var ToolCallEvent = class {
   constructor(call) {
     this["event.name"] = "tool_call";
     this["event.timestamp"] = (/* @__PURE__ */ new Date()).toISOString();
+    this.call_id = call.request.callId;
     this.function_name = call.request.name;
     this.function_args = call.request.name === ToolNames.STRUCTURED_OUTPUT ? { ...STRUCTURED_OUTPUT_REDACTED_ARGS } : call.request.args;
     this.duration_ms = call.durationMs ?? 0;
     this.status = call.status;
+    this.execution_status = call.response.executionStatus;
     this.success = call.status === "success";
     this.decision = call.outcome ? getDecisionFromOutcome(call.outcome) : void 0;
     this.error = call.response.error?.message;
@@ -16154,7 +16285,7 @@ async function runSideQuery(config, options) {
 __name(runSideQuery, "runSideQuery");
 
 // packages/core/src/services/visionBridge/vision-bridge-service.ts
-var debugLogger7 = createDebugLogger("VISION_BRIDGE");
+var debugLogger8 = createDebugLogger("VISION_BRIDGE");
 var turnImageCounts = /* @__PURE__ */ new WeakMap();
 var BRIDGE_MAX_OUTPUT_TOKENS = 2048;
 var VISION_BRIDGE_TIMEOUT_MS = 3e4;
@@ -16424,7 +16555,7 @@ async function runVisionBridge(params) {
     try {
       timeoutSignal = AbortSignal.timeout(timeoutMs);
       combinedSignal = AbortSignal.any([signal, timeoutSignal]);
-      debugLogger7.debug(`calling ${modelId} for ${toConvert.length} image(s)`);
+      debugLogger8.debug(`calling ${modelId} for ${toConvert.length} image(s)`);
       const { text } = await runSideQuery(config, {
         contents: requestContents,
         abortSignal: combinedSignal,
@@ -16443,7 +16574,7 @@ async function runVisionBridge(params) {
       });
       const description = stripThinkTags(text ?? "");
       if (description.length === 0) {
-        debugLogger7.warn(`${modelId} returned an empty description`);
+        debugLogger8.warn(`${modelId} returned an empty description`);
         return failure(
           "the vision model returned no description",
           parts,
@@ -16451,7 +16582,7 @@ async function runVisionBridge(params) {
           { modelId, ...egress }
         );
       }
-      debugLogger7.debug(
+      debugLogger8.debug(
         `vision bridge transcription via ${modelId} (${description.length} chars)`
       );
       return {
@@ -16477,7 +16608,7 @@ async function runVisionBridge(params) {
       };
     } catch (error) {
       if (signal.aborted) {
-        debugLogger7.debug(`conversion cancelled via ${modelId}`);
+        debugLogger8.debug(`conversion cancelled via ${modelId}`);
         return {
           applied: false,
           status: "skipped",
@@ -16489,13 +16620,13 @@ async function runVisionBridge(params) {
       }
       const timedOut = !!combinedSignal?.aborted && !!timeoutSignal?.aborted;
       if (timedOut && attempt < VISION_BRIDGE_MAX_ATTEMPTS) {
-        debugLogger7.warn(
+        debugLogger8.warn(
           `conversion attempt ${attempt} via ${modelId} timed out after ${timeoutMs}ms; retrying`
         );
         continue;
       }
       const reason = timedOut ? `timed out after ${timeoutMs}ms (${VISION_BRIDGE_MAX_ATTEMPTS} attempts)` : error instanceof Error ? error.message : String(error);
-      debugLogger7.warn(`conversion failed via ${modelId}: ${reason}`);
+      debugLogger8.warn(`conversion failed via ${modelId}: ${reason}`);
       return failure(reason, parts, omittedCount, {
         modelId,
         // The timeout message is safe to show; an arbitrary provider error is not
@@ -16510,7 +16641,7 @@ async function runVisionBridge(params) {
 __name(runVisionBridge, "runVisionBridge");
 
 // packages/core/src/tools/read-file.ts
-var debugLogger8 = createDebugLogger("READ_FILE_CACHE");
+var debugLogger9 = createDebugLogger("READ_FILE_CACHE");
 var ReadFileToolInvocation = class extends BaseToolInvocation {
   constructor(config, params) {
     super(params);
@@ -16562,7 +16693,7 @@ var ReadFileToolInvocation = class extends BaseToolInvocation {
     try {
       stats = await fs7.stat(absPath);
     } catch (err) {
-      debugLogger8.debug("stat-failed", {
+      debugLogger9.debug("stat-failed", {
         path: absPath,
         code: err.code
       });
@@ -16572,10 +16703,10 @@ var ReadFileToolInvocation = class extends BaseToolInvocation {
       if (status.state === "fresh" && status.entry.lastReadAt !== void 0 && status.entry.lastReadWasFull && status.entry.lastReadCacheable && // Only quote-back if that read is still in history (issue
       // #4239: idle microcompaction flips this off when it blanks it).
       status.entry.readResidentInHistory && (status.entry.lastWriteAt === void 0 || status.entry.lastReadAt > status.entry.lastWriteAt)) {
-        debugLogger8.debug("hit", { path: absPath });
+        debugLogger9.debug("hit", { path: absPath });
         return this.unchangedResult(absPath);
       }
-      debugLogger8.debug("miss", { path: absPath, state: status.state });
+      debugLogger9.debug("miss", { path: absPath, state: status.state });
     }
     const prepareForVisionBridge = shouldRunVisionBridge(this.config);
     let result = await processSingleFileContent(
@@ -16660,7 +16791,7 @@ ${result.llmContent}`;
     if (!candidate) return result;
     const { imageParts } = splitImageParts(result.llmContent);
     if (imageParts.length === 0 || !hasImageParts(imageParts)) {
-      debugLogger8.debug("pdf vision bridge candidate contained no images");
+      debugLogger9.debug("pdf vision bridge candidate contained no images");
       return this.restorePdfFallback(result, "Vision bridge could not run.");
     }
     const sourceContext = {
@@ -16681,7 +16812,7 @@ ${result.llmContent}`;
       const notice = formatVisionBridgeNotice(bridgeResult);
       if (bridgeResult.status === "ok" && bridgeResult.applied && bridgeResult.parts != null) {
         if (bridgeResult.convertedCount !== imageParts.length || bridgeResult.omittedCount !== 0) {
-          debugLogger8.debug("pdf vision bridge omitted candidate pages");
+          debugLogger9.debug("pdf vision bridge omitted candidate pages");
           return this.restorePdfFallback(
             result,
             `${notice} The transcription was discarded because the bridge did not transcribe every rendered PDF page.`
@@ -16691,7 +16822,7 @@ ${result.llmContent}`;
         if (bridgedParts.some(
           (part) => part.inlineData != null || part.fileData != null
         )) {
-          debugLogger8.debug("pdf vision bridge returned media data");
+          debugLogger9.debug("pdf vision bridge returned media data");
           return this.restorePdfFallback(
             result,
             `${notice} The transcription was discarded because the bridge returned an unsafe media payload.`
@@ -16725,7 +16856,7 @@ ${result.llmContent}`;
       );
     } catch (error) {
       signal.throwIfAborted();
-      debugLogger8.debug(
+      debugLogger9.debug(
         `pdf vision bridge failed before replacement: ${String(error instanceof Error ? error.message : error)}`
       );
       return this.restorePdfFallback(