@qwen-code/qwen-code 0.21.3 → 0.21.4

package/chunks/{chunk-UQDFEU47.js → chunk-E2SYUEIA.js}

@@ -71,7 +71,7 @@ import {
   RUNTIME_SNAPSHOT_PREFIX,
   buildModelIdContext,
   resolveModelId
-} from "./chunk-XUMAD5IT.js";
+} from "./chunk-DZPOYHBT.js";
 import {
   ARTIFACT_TITLE_MAX_LENGTH,
   ARTIFACT_WORKSPACE_PATH_MAX_LENGTH,
@@ -163,7 +163,7 @@ import {
   runWithRuntimeContentGenerator,
   shouldUsePlanOnlyReminderInSubagentContext,
   spawnBlockReason
-} from "./chunk-TZTBZ25J.js";
+} from "./chunk-LLMGP5IC.js";
 import {
   getTeammateContext,
   isTeammate,
@@ -202,7 +202,7 @@ import {
   selectForkHistory,
   stripSystemReminderBlocks,
   validateForkToolList
-} from "./chunk-SRY26X4H.js";
+} from "./chunk-7UXI6P72.js";
 import {
   collectAvailableSkillEntries,
   renderAvailableSkillsBlock
@@ -221,6 +221,9 @@ import {
   isPathWithinRoot,
   require_ignore
 } from "./chunk-432XCUHF.js";
+import {
+  DashScopeOpenAICompatibleProvider
+} from "./chunk-YXEVDA66.js";
 import {
   openBrowserSecurely,
   shouldAttemptBrowserLaunch
@@ -380,7 +383,7 @@ import {
   updateMCPServerStatus,
   writeLine,
   writeLineSync
-} from "./chunk-4K3RV3OA.js";
+} from "./chunk-JDJ7SC4E.js";
 import {
   E_TIMEOUT,
   Mutex,
@@ -439,7 +442,7 @@ import {
   createContentGenerator,
   resetPreloadedContentGenerator,
   resolveContentGeneratorConfigWithSources
-} from "./chunk-H35Q5CEG.js";
+} from "./chunk-TXZDRD36.js";
 import {
   normalizeMcpToolName,
   sanitizeToolNameForProvider
@@ -19962,13 +19965,15 @@ var BaseLlmClient = class {
         );
         let text = "";
         let usage;
+        let hadToolCall = false;
         for await (const chunk of responseStream) {
           text += getResponseText(chunk) ?? "";
+          hadToolCall ||= (getFunctionCalls(chunk)?.length ?? 0) > 0;
           if (chunk.usageMetadata) {
             usage = chunk.usageMetadata;
           }
         }
-        return { text, usage };
+        return { text, usage, hadToolCall };
       } : async () => {
         const result2 = await contentGenerator.generateContent(
           request,
@@ -19976,7 +19981,8 @@ var BaseLlmClient = class {
         );
         return {
           text: getResponseText(result2) ?? "",
-          usage: result2.usageMetadata
+          usage: result2.usageMetadata,
+          hadToolCall: (getFunctionCalls(result2)?.length ?? 0) > 0
         };
       };
       const result = await retryWithBackoff(apiCall, {
@@ -20008,7 +20014,8 @@ var BaseLlmClient = class {
       });
       return {
         text: result.text.trim(),
-        usage: result.usage
+        usage: result.usage,
+        hadToolCall: result.hadToolCall
       };
     } catch (error) {
       if (abortSignal.aborted) {
@@ -22132,7 +22139,7 @@ You have access to the ${ToolNames.TODO_WRITE} tool to keep user-visible progres
 
 When you create a todo list:
 - Keep it short and outcome-oriented. Use a few meaningful, logically ordered, verifiable steps rather than one item per error, file, command, or minor edit.
-- For complex work delegated through top-level Agent calls, create the relevant todo first and pass its ID as \`todo_id\` so the execution can be associated with the plan node.
+- When an active Todo plan covers work delegated through top-level Agent calls, pass the matching Todo ID as \`todo_id\` so the execution can be associated with that plan node. Do not create a Todo solely to wrap a delegation that does not otherwise need task tracking.
 - Keep at most one item in_progress. Keep the list current, mark finished work completed, and revise it when the scope or approach changes. When work completes together, update multiple statuses in one tool call rather than making bookkeeping-only calls.
 - Do not repeat the full todo list in prose after calling the tool; briefly communicate only important context or the next step.
 
@@ -29318,17 +29325,14 @@ function recordSegmentBytes(index, uuid) {
   return entry?.segments.reduce((total, segment) => total + segment.length, 0) ?? 0;
 }
 __name(recordSegmentBytes, "recordSegmentBytes");
-function selectPageUuids(index, sessionId, position, limit, maxBytes) {
+function selectPageUuids(index, position, limit, maxBytes) {
   const candidates = index.activeUuids.slice(position, position + limit);
   if (maxBytes === void 0) return candidates;
   const selected = [];
   let selectedBytes = 0;
   for (const uuid of candidates) {
     const bytes = recordSegmentBytes(index, uuid);
-    if (selected.length === 0 && bytes > maxBytes) {
-      throw new SessionTranscriptPageTooLargeError(sessionId, bytes, maxBytes);
-    }
-    if (selectedBytes + bytes > maxBytes) break;
+    if (selected.length > 0 && selectedBytes + bytes > maxBytes) break;
     selected.push(uuid);
     selectedBytes += bytes;
   }
@@ -29340,7 +29344,7 @@ function isReplayTurnStart(index, uuid) {
   return entry?.type === "user" && entry.subtype !== "mid_turn_user_message";
 }
 __name(isReplayTurnStart, "isReplayTurnStart");
-function selectBackwardPageUuids(index, sessionId, position, limit, maxBytes) {
+function selectBackwardPageUuids(index, position, limit, maxBytes) {
   let start = Math.max(0, position - limit);
   for (let i = start; i < position; i++) {
     if (isReplayTurnStart(index, index.activeUuids[i])) {
@@ -29356,10 +29360,9 @@ function selectBackwardPageUuids(index, sessionId, position, limit, maxBytes) {
   for (let i = position - 1; i >= start; i--) {
     const uuid = index.activeUuids[i];
     const bytes = recordSegmentBytes(index, uuid);
-    if (selectedStart === position && maxBytes !== void 0 && bytes > maxBytes) {
-      throw new SessionTranscriptPageTooLargeError(sessionId, bytes, maxBytes);
+    if (selectedStart < position && maxBytes !== void 0 && selectedBytes + bytes > maxBytes) {
+      break;
     }
-    if (maxBytes !== void 0 && selectedBytes + bytes > maxBytes) break;
     selectedStart = i;
     selectedBytes += bytes;
   }
@@ -29371,7 +29374,6 @@ function selectBackwardPageUuids(index, sessionId, position, limit, maxBytes) {
       break;
     }
   }
-  let expandedSelection = false;
   if (alignedToReplayBoundary && selectedStart > 0) {
     let previousTurnStart = selectedStart - 1;
     while (previousTurnStart >= 0 && !isReplayTurnStart(index, index.activeUuids[previousTurnStart])) {
@@ -29379,23 +29381,11 @@ function selectBackwardPageUuids(index, sessionId, position, limit, maxBytes) {
     }
     if (previousTurnStart < 0) {
       selectedStart = 0;
-      expandedSelection = true;
     }
   } else if (!alignedToReplayBoundary) {
     while (selectedStart > 0 && !isReplayTurnStart(index, index.activeUuids[selectedStart])) {
       selectedStart--;
     }
-    expandedSelection = true;
-  }
-  if (expandedSelection && maxBytes !== void 0) {
-    const alignedBytes = index.activeUuids.slice(selectedStart, position).reduce((total, uuid) => total + recordSegmentBytes(index, uuid), 0);
-    if (alignedBytes > maxBytes) {
-      throw new SessionTranscriptPageTooLargeError(
-        sessionId,
-        alignedBytes,
-        maxBytes
-      );
-    }
   }
   return {
     uuids: index.activeUuids.slice(selectedStart, position),
@@ -29825,8 +29815,8 @@ var SessionTranscriptReader = class {
       );
       throw new InvalidSessionTranscriptCursorError();
     }
-    const backwardPage = direction === "backward" ? selectBackwardPageUuids(index, sessionId, position, limit, maxBytes) : void 0;
-    const pageUuids = backwardPage?.uuids ?? selectPageUuids(index, sessionId, position, limit, maxBytes);
+    const backwardPage = direction === "backward" ? selectBackwardPageUuids(index, position, limit, maxBytes) : void 0;
+    const pageUuids = backwardPage?.uuids ?? selectPageUuids(index, position, limit, maxBytes);
     const nextPosition = backwardPage?.nextPosition ?? position + pageUuids.length;
     const records = await readAggregatedRecords(index, pageUuids);
     const backwardGoalState = direction === "backward" ? await readGoalStateBeforePosition(index, nextPosition) : void 0;
@@ -35318,6 +35308,15 @@ function getCitations(resp) {
 }
 __name(getCitations, "getCitations");
 
+// packages/core/src/core/openaiContentGenerator/prefix-caching.ts
+init_esbuild_shims();
+function supportsOpenAIPrefixCaching(contentGeneratorConfig) {
+  return DashScopeOpenAICompatibleProvider.isDashScopeProvider(
+    contentGeneratorConfig
+  );
+}
+__name(supportsOpenAIPrefixCaching, "supportsOpenAIPrefixCaching");
+
 // packages/core/src/services/postCompactAttachments.ts
 init_esbuild_shims();
 import { readFile as readFile7, stat as stat4 } from "node:fs/promises";
@@ -35776,6 +35775,21 @@ Additional Instructions:
 ${parts.join("\n\n")}`;
 }
 __name(buildCompressionSystemPrompt, "buildCompressionSystemPrompt");
+function supportsCompressionCacheSharing(config) {
+  const provider = config.getContentGeneratorConfig();
+  if (provider.enableCacheControl === false) return false;
+  if (provider.authType === "anthropic" /* USE_ANTHROPIC */) return true;
+  return (provider.authType === "qwen-oauth" /* QWEN_OAUTH */ || provider.authType === "openai" /* USE_OPENAI */) && supportsOpenAIPrefixCaching(provider);
+}
+__name(supportsCompressionCacheSharing, "supportsCompressionCacheSharing");
+function hasStateSnapshot(summary) {
+  const stripped = stripAnalysisBlock(summary);
+  const startTag = "<state_snapshot>";
+  const start = stripped.indexOf(startTag);
+  const end = stripped.indexOf("</state_snapshot>", start + startTag.length);
+  return start >= 0 && end > start + startTag.length && stripped.slice(start + startTag.length, end).trim().length > 0;
+}
+__name(hasStateSnapshot, "hasStateSnapshot");
 var ChatCompressionService = class {
   static {
     __name(this, "ChatCompressionService");
@@ -35916,7 +35930,9 @@ var ChatCompressionService = class {
         }
       }
     }
-    const summaryResult = await runSideQuery(config, {
+    const abortSignal = signal ?? new AbortController().signal;
+    abortSignal.throwIfAborted();
+    const runColdCompression = /* @__PURE__ */ __name(() => runSideQuery(config, {
       purpose: "chat-compression",
       skipOutputLanguagePreference: true,
       model: effectiveCompactionModel,
@@ -35953,9 +35969,77 @@ var ChatCompressionService = class {
         thinkingConfig: { includeThoughts: false },
         maxOutputTokens: COMPACT_MAX_OUTPUT_TOKENS
       },
-      abortSignal: signal ?? new AbortController().signal,
+      abortSignal,
       promptId
-    });
+    }), "runColdCompression");
+    let summaryResult;
+    let usedCacheSharing = false;
+    const canShareCache = effectiveCompactionModel === config.getModel() && slim.stats.imagesStripped === 0 && slim.stats.documentsStripped === 0 && supportsCompressionCacheSharing(config);
+    if (canShareCache) {
+      try {
+        const generationConfig = {
+          ...chat.getGenerationConfig(),
+          ...opts.requestGenerationConfig
+        };
+        const mainSystemInstruction = generationConfig.systemInstruction;
+        delete generationConfig.systemInstruction;
+        delete generationConfig.abortSignal;
+        const sharedResult = await config.getBaseLlmClient().generateText({
+          contents: [
+            ...sideQueryHistory,
+            {
+              role: "user",
+              parts: [
+                {
+                  text: `${systemInstruction}
+
+Do not call tools; tool execution is disabled for this request. First, reason in your <analysis> block. Then, produce the <state_snapshot> XML.`
+                }
+              ]
+            }
+          ],
+          model: effectiveCompactionModel,
+          systemInstruction: mainSystemInstruction,
+          config: {
+            ...generationConfig,
+            ...config.getContentGeneratorConfig().authType === "anthropic" /* USE_ANTHROPIC */ ? {
+              thinkingConfig: {
+                ...generationConfig.thinkingConfig,
+                // Manual Anthropic thinking requires budget_tokens to be
+                // strictly below max_tokens. Preserve thinking for cache
+                // compatibility while keeping this bounded request valid.
+                thinkingBudget: COMPACT_MAX_OUTPUT_TOKENS - 1
+              }
+            } : {},
+            maxOutputTokens: COMPACT_MAX_OUTPUT_TOKENS
+          },
+          abortSignal,
+          promptId,
+          stream: true,
+          maxAttempts: 1
+        });
+        if (!sharedResult.hadToolCall && hasStateSnapshot(sharedResult.text)) {
+          summaryResult = sharedResult;
+          usedCacheSharing = true;
+          config.getDebugLogger().debug(
+            `[chat-compression] cache-sharing request succeeded; cachedContentTokenCount=${sharedResult.usage?.cachedContentTokenCount ?? 0}`
+          );
+        } else {
+          config.getDebugLogger().warn(
+            `[chat-compression] cache-sharing response was unusable (${sharedResult.hadToolCall ? "tool call" : "invalid state snapshot"}); falling back to the dedicated summarizer.`
+          );
+        }
+      } catch (error) {
+        if (abortSignal.aborted) throw error;
+        config.getDebugLogger().warn(
+          `[chat-compression] cache-sharing request failed; falling back to the dedicated summarizer: ${String(error)}`
+        );
+      }
+    }
+    if (!summaryResult) {
+      abortSignal.throwIfAborted();
+      summaryResult = await runColdCompression();
+    }
     const summary = summaryResult.text;
     const isSummaryEmpty = !summary || stripAnalysisBlock(summary).trim().length === 0;
     const compressionUsageMetadata = summaryResult.usage;
@@ -35976,7 +36060,7 @@ var ChatCompressionService = class {
         `[chat-compression] compression side-query omitted usage metadata; using local estimate for summary output token count (${compressionOutputTokenCount}).`
       );
     }
-    if (!isSummaryEmpty && typeof compressionOutputTokenCount === "number" && compressionOutputTokenCount >= COMPACT_MAX_OUTPUT_TOKENS) {
+    if (!usedCacheSharing && !isSummaryEmpty && typeof compressionOutputTokenCount === "number" && compressionOutputTokenCount >= COMPACT_MAX_OUTPUT_TOKENS) {
       config.getDebugLogger().warn(
         `[chat-compression] summary output reached the COMPACT_MAX_OUTPUT_TOKENS cap (${COMPACT_MAX_OUTPUT_TOKENS}); dropping potentially-truncated result. This counts as a compression failure for the per-chat circuit breaker.`
       );
@@ -36039,7 +36123,7 @@ var ChatCompressionService = class {
           }
         ];
       }
-      if (typeof compressionInputTokenCount === "number" && compressionInputTokenCount > 0 && typeof compressionOutputTokenCount === "number" && compressionOutputTokenCount > 0) {
+      if (!usedCacheSharing && typeof compressionInputTokenCount === "number" && compressionInputTokenCount > 0 && typeof compressionOutputTokenCount === "number" && compressionOutputTokenCount > 0) {
         canCalculateNewTokenCount = true;
         const compressedHistoryTokenCount = Math.max(
           0,
@@ -36071,7 +36155,7 @@ var ChatCompressionService = class {
           newTokenCount = estimatedNonVisibleTokenCount + estimatedNewVisibleTokenCount;
           canCalculateNewTokenCount = true;
           config.getDebugLogger().debug(
-            `[chat-compression] usage metadata missing; estimated post-compression token count by preserving the API-reported non-visible remainder (${estimatedNonVisibleTokenCount}) and replacing the visible-history estimate (${estimatedOriginalVisibleTokenCount} -> ${estimatedNewVisibleTokenCount}).`
+            `[chat-compression] ${usedCacheSharing ? "cache-sharing token accounting" : "usage metadata missing"}; estimated post-compression token count by preserving the API-reported non-visible remainder (${estimatedNonVisibleTokenCount}) and replacing the visible-history estimate (${estimatedOriginalVisibleTokenCount} -> ${estimatedNewVisibleTokenCount}).`
           );
         }
       }
@@ -36082,7 +36166,9 @@ var ChatCompressionService = class {
         tokens_before: originalTokenCount,
         tokens_after: newTokenCount,
         compression_input_token_count: compressionInputTokenCount,
-        compression_output_token_count: compressionOutputTokenCount
+        compression_output_token_count: compressionOutputTokenCount,
+        cache_sharing_attempted: canShareCache,
+        cache_sharing_used: usedCacheSharing
       })
     );
     if (isSummaryEmpty) {
@@ -36787,14 +36873,14 @@ var RETRYABLE_STREAM_TRANSPORT_CODES = /* @__PURE__ */ new Set([
 // packages/core/src/core/geminiChat.ts
 var debugLogger22 = createDebugLogger("QWEN_CODE_CHAT");
 var GEMINI_EMPTY_CONTENT_PLACEHOLDER = "(empty content)";
-function isToolCallPreparationOnly(response) {
-  if (getToolCallPreparations(response).length === 0) return false;
-  const hasCandidateOutput = response.candidates?.some(
-    (candidate) => Boolean(candidate.finishReason) || (candidate.content?.parts?.length ?? 0) > 0
+function hasCandidateOutput(response) {
+  return Boolean(
+    response.candidates?.some(
+      (candidate) => Boolean(candidate.finishReason) || (candidate.content?.parts?.length ?? 0) > 0
+    )
   );
-  return !hasCandidateOutput && !response.usageMetadata;
 }
-__name(isToolCallPreparationOnly, "isToolCallPreparationOnly");
+__name(hasCandidateOutput, "hasCandidateOutput");
 function hasNonThoughtCandidateParts(response) {
   return Boolean(
     response.candidates?.some(
@@ -36927,11 +37013,24 @@ var INVALID_STREAM_RETRY_CONFIG = {
 };
 var TRANSPORT_STREAM_RETRY_CONFIG = {
   maxRetries: 2,
-  initialDelayMs: 1e3
+  initialDelayMs: 1e3,
+  /**
+   * Budget for *continuation* recovery after a socket-level cut that already
+   * delivered output (issue #7832). This is a different mechanism from the
+   * `maxRetries` replay above and therefore has its own budget: a replay
+   * re-sends the request from scratch and is only legal before any chunk
+   * reached callers, while a continuation keeps the delivered output and asks
+   * the model to resume from it. A single long generation can be cut more than
+   * once by the same gateway idle timeout, so this is sized like
+   * {@link MAX_OUTPUT_RECOVERY_ATTEMPTS} rather than like the replay budget.
+   */
+  maxContinuationRetries: 3
 };
 var FIRST_SEND_CLAMP_OVERHEAD_PAD = 2e4;
 var MAX_OUTPUT_RECOVERY_ATTEMPTS = 3;
-var OUTPUT_RECOVERY_MESSAGE = "Output token limit hit. Resume directly \u2014 no apology, no recap of what you were doing. Pick up mid-thought if that is where the cut happened. Break remaining work into smaller pieces.";
+var RECOVERY_RESUME_INSTRUCTION = "Resume directly \u2014 no apology, no recap of what you were doing. Pick up mid-thought if that is where the cut happened. Break remaining work into smaller pieces.";
+var OUTPUT_RECOVERY_MESSAGE = `Output token limit hit. ${RECOVERY_RESUME_INSTRUCTION}`;
+var TRANSPORT_CONTINUATION_MESSAGE = `The connection dropped mid-response. ${RECOVERY_RESUME_INSTRUCTION}`;
 var OUTPUT_RECOVERY_TAIL_CHARS = 1200;
 var RECOVERY_OVERLAP_MAX_SCAN_CHARS = 4e3;
 var RECOVERY_OVERLAP_MIN_BYTES = 6;
@@ -37046,20 +37145,26 @@ function sanitizeRecoverySuffixTail(tail) {
   return tail.replace(/<\/previous_response_suffix>/g, "<\u200B/previous_response_suffix>").replace(/<previous_response_suffix>/g, "<\u200Bprevious_response_suffix>");
 }
 __name(sanitizeRecoverySuffixTail, "sanitizeRecoverySuffixTail");
-function buildOutputRecoveryMessage(previousModelTurn) {
-  const previousText = previousModelTurn?.role === "model" ? getPlainTextFromParts(previousModelTurn.parts) : "";
+function buildRecoveryMessageFromText(lead, previousText) {
   if (previousText.trim().length === 0) {
-    return OUTPUT_RECOVERY_MESSAGE;
+    return lead;
   }
   const rawTail = previousText.length > OUTPUT_RECOVERY_TAIL_CHARS ? previousText.slice(-OUTPUT_RECOVERY_TAIL_CHARS) : previousText;
   const tail = sanitizeRecoverySuffixTail(rawTail);
-  return `${OUTPUT_RECOVERY_MESSAGE}
+  return `${lead}
 
 The previous assistant response ended with this exact suffix. Do not repeat any line, table row, code line, or prose that already appears in it; output only text that comes after this suffix:
 
 <previous_response_suffix>
 ` + tail + "\n</previous_response_suffix>";
 }
+__name(buildRecoveryMessageFromText, "buildRecoveryMessageFromText");
+function buildOutputRecoveryMessage(previousModelTurn) {
+  return buildRecoveryMessageFromText(
+    OUTPUT_RECOVERY_MESSAGE,
+    previousModelTurn?.role === "model" ? getPlainTextFromParts(previousModelTurn.parts) : ""
+  );
+}
 __name(buildOutputRecoveryMessage, "buildOutputRecoveryMessage");
 function appendRecoveryContinuationParts(previousParts, continuationParts) {
   const mergedParts = [...previousParts ?? []];
@@ -37247,6 +37352,26 @@ var PROTOCOL_TAG_PREFIXES = [
   "<summary",
   "</summary"
 ];
+var LEAKED_TOOL_CALL_TAGS = /[}\]]\s*<\/parameter>\s*<\/function>/iy;
+function hasLeakedToolCallTags(text) {
+  let inString = false;
+  let escaped = false;
+  for (let i = 0; i < text.length; i++) {
+    const char = text[i];
+    if (inString) {
+      if (escaped) escaped = false;
+      else if (char === "\\") escaped = true;
+      else if (char === '"') inString = false;
+    } else if (char === '"') {
+      inString = true;
+    } else if (char === "}" || char === "]") {
+      LEAKED_TOOL_CALL_TAGS.lastIndex = i;
+      if (LEAKED_TOOL_CALL_TAGS.test(text)) return true;
+    }
+  }
+  return false;
+}
+__name(hasLeakedToolCallTags, "hasLeakedToolCallTags");
 var LeadingProtocolTagLeakDetector = class {
   static {
     __name(this, "LeadingProtocolTagLeakDetector");
@@ -37257,6 +37382,7 @@ var LeadingProtocolTagLeakDetector = class {
     if (this.state === "clean") return text;
     if (this.state === "leaked") return "";
     this.buffer += text;
+    if (this.state === "json") return "";
     const candidate = this.buffer.trimStart().toLowerCase();
     if (!candidate) return "";
     if (PROTOCOL_TAG_PREFIXES.some((prefix) => prefix.startsWith(candidate))) {
@@ -37269,12 +37395,29 @@ var LeadingProtocolTagLeakDetector = class {
         return "";
       }
     }
-    this.state = "clean";
-    const output = this.buffer;
-    this.buffer = "";
-    return output;
+    if (candidate.startsWith("{")) {
+      this.state = "json";
+      return "";
+    }
+    if (candidate.startsWith("[")) {
+      const normalized2 = candidate.replace(/\s/g, "");
+      if (normalized2 === "[") return "";
+      if (normalized2.startsWith("[{")) {
+        this.state = "json";
+        return "";
+      }
+    }
+    return this.release();
   }
   finish() {
+    if (this.state === "json") {
+      if (hasLeakedToolCallTags(this.buffer)) {
+        this.state = "leaked";
+        this.buffer = "";
+        return "";
+      }
+      return this.release();
+    }
     if (this.state !== "detecting") return "";
     const candidate = this.buffer.trimStart().toLowerCase();
     if (candidate && PROTOCOL_TAG_PREFIXES.some((prefix) => prefix.startsWith(candidate))) {
@@ -37282,8 +37425,11 @@ var LeadingProtocolTagLeakDetector = class {
       this.buffer = "";
       return "";
     }
-    this.state = "clean";
+    return this.release();
+  }
+  release() {
     const output = this.buffer;
+    this.state = "clean";
     this.buffer = "";
     return output;
   }
@@ -37664,6 +37810,7 @@ var GeminiChat = class {
       originalTokenCount: options2?.originalTokenCountOverride ?? this.lastPromptTokenCount,
       pendingUserMessage: options2?.pendingUserMessage,
       precomputedEffectiveTokens: options2?.precomputedEffectiveTokens,
+      requestGenerationConfig: options2?.requestGenerationConfig,
       trigger: options2?.trigger,
       customInstructions: options2?.customInstructions,
       signal
@@ -37893,6 +38040,7 @@ var GeminiChat = class {
           {
             pendingUserMessage: userContent,
             precomputedEffectiveTokens: effectiveTokens,
+            requestGenerationConfig: params.config,
             deferChatCompressionRecord: shouldForceFromHard,
             // Hard-rescue is force=true to bypass the cheap-gate breaker
             // but it remains a semantically AUTOMATIC trigger. Tag the
@@ -38033,6 +38181,10 @@ var GeminiChat = class {
         let protocolTagLeakRetryCount = 0;
         const totalInvalidStreamRetryCount = /* @__PURE__ */ __name(() => transientInvalidStreamRetryCount + protocolTagLeakRetryCount, "totalInvalidStreamRetryCount");
         let transportStreamRetryCount = 0;
+        let transportContinuationCount = 0;
+        let transportContinuationText = "";
+        let transportAttemptText = "";
+        let transportContinuationPrefix = "";
         let reactiveCompressionAttempted = false;
         let suppressNextRetryEvent = false;
         let streamYieldedAnyChunk = false;
@@ -38059,18 +38211,49 @@ var GeminiChat = class {
         );
         const shouldEscalateMaxOutputTokens = effectiveInitialMaxOutputTokens < escalatedLimit;
         let lastFinishReason;
+        const buildAttemptContents = /* @__PURE__ */ __name(() => transportContinuationPrefix.length > 0 ? [
+          ...requestContents,
+          {
+            role: "model",
+            parts: [{ text: transportContinuationPrefix }]
+          },
+          createUserContent([
+            {
+              text: buildRecoveryMessageFromText(
+                TRANSPORT_CONTINUATION_MESSAGE,
+                transportContinuationPrefix
+              )
+            }
+          ])
+        ] : requestContents, "buildAttemptContents");
+        const resetTransportContinuation = /* @__PURE__ */ __name(() => {
+          transportContinuationCount = 0;
+          transportContinuationText = "";
+          transportAttemptText = "";
+          transportContinuationPrefix = "";
+        }, "resetTransportContinuation");
+        const foldTransportAttemptText = /* @__PURE__ */ __name(() => {
+          transportContinuationText += getRecoveryContinuationSuffix(
+            transportContinuationText,
+            transportAttemptText
+          );
+          transportAttemptText = "";
+        }, "foldTransportAttemptText");
         for (; ; ) {
+          transportAttemptText = "";
           let streamYieldedChunk = false;
           let streamYieldedContentChunk = false;
+          let streamYieldedFunctionCall = false;
           try {
             if (suppressNextRetryEvent) {
               suppressNextRetryEvent = false;
-            } else if (rateLimitRetryCount > 0 || totalInvalidStreamRetryCount() > 0 || transportStreamRetryCount > 0) {
+            } else if (rateLimitRetryCount > 0 || totalInvalidStreamRetryCount() > 0 || transportStreamRetryCount > 0 || transportContinuationCount > 0) {
+              resetTransportContinuation();
               yield { type: "retry" /* RETRY */ };
             }
             const stream2 = await self2.makeApiCallAndProcessStream(
               model,
-              requestContents,
+              buildAttemptContents(),
               params,
               prompt_id,
               requestOverrides,
@@ -38078,21 +38261,31 @@ var GeminiChat = class {
             );
             lastFinishReason = void 0;
             for await (const chunk of stream2) {
-              if (!isToolCallPreparationOnly(chunk)) {
+              if (hasCandidateOutput(chunk)) {
                 streamYieldedChunk = true;
                 streamYieldedAnyChunk = true;
               }
               if (hasNonThoughtCandidateParts(chunk)) {
                 streamYieldedContentChunk = true;
               }
+              const chunkParts = chunk.candidates?.[0]?.content?.parts;
+              transportAttemptText += getPlainTextFromParts(chunkParts);
+              if (chunkParts?.some((part) => part.functionCall)) {
+                streamYieldedFunctionCall = true;
+              }
               const fr2 = chunk.candidates?.[0]?.finishReason;
               if (fr2) lastFinishReason = fr2;
               yield { type: "chunk" /* CHUNK */, value: chunk };
             }
             lastError = null;
+            if (transportContinuationPrefix.length > 0) {
+              self2.prependTextToLastModelTurn(transportContinuationPrefix);
+              transportContinuationPrefix = "";
+            }
             break;
           } catch (error) {
             lastError = error;
+            foldTransportAttemptText();
             const classification = classifyRetryError(error, {
               authType: cgConfig?.authType,
               extraRetryErrorCodes
@@ -38165,7 +38358,15 @@ var GeminiChat = class {
             const isRetryableStreamTransportError = classification.kind === "transport" && classification.transportCode !== void 0 && RETRYABLE_STREAM_TRANSPORT_CODES.has(
               classification.transportCode
             );
-            if (isRetryableStreamTransportError && !streamYieldedContentChunk && transportStreamRetryCount < TRANSPORT_STREAM_RETRY_CONFIG.maxRetries) {
+            if (isRetryableStreamTransportError && !streamYieldedContentChunk && // `streamYieldedContentChunk` is per-attempt, so on its own it
+            // cannot tell "nothing has been delivered" from "this attempt
+            // was cut while thinking, after earlier attempts already put
+            // text on screen". Only the first is replayable; replaying the
+            // second discards output the caller is watching. The
+            // accumulated buffer is what distinguishes them, and it must be
+            // consulted here because this branch is checked before the
+            // continuation one below.
+            transportContinuationText.trim().length === 0 && transportStreamRetryCount < TRANSPORT_STREAM_RETRY_CONFIG.maxRetries) {
               self2.popPendingPartialAssistantTurn();
               transportStreamRetryCount++;
               const delayMs = TRANSPORT_STREAM_RETRY_CONFIG.initialDelayMs * transportStreamRetryCount;
@@ -38180,6 +38381,28 @@ var GeminiChat = class {
                 transportCode: classification.transportCode
               });
               yield { type: "retry" /* RETRY */ };
+              resetTransportContinuation();
+              suppressNextRetryEvent = true;
+              await delay2(delayMs, params.config?.abortSignal).promise;
+              continue;
+            }
+            const canContinueAfterTransportCut = isRetryableStreamTransportError && !streamYieldedFunctionCall && transportContinuationText.trim().length > 0 && transportContinuationCount < TRANSPORT_STREAM_RETRY_CONFIG.maxContinuationRetries;
+            if (canContinueAfterTransportCut) {
+              self2.popPendingPartialAssistantTurn();
+              transportContinuationCount++;
+              transportContinuationPrefix = transportContinuationText;
+              const delayMs = TRANSPORT_STREAM_RETRY_CONFIG.initialDelayMs * transportContinuationCount;
+              debugLogger22.warn("Transport stream continuation scheduled", {
+                retryPath: "stream",
+                retryDecision: "continue",
+                attempt: transportContinuationCount,
+                maxRetries: TRANSPORT_STREAM_RETRY_CONFIG.maxContinuationRetries,
+                retryDelayMs: delayMs,
+                errorKind: classification.kind,
+                transportCode: classification.transportCode,
+                deliveredChars: transportContinuationText.length
+              });
+              yield { type: "retry" /* RETRY */, isContinuation: true };
               suppressNextRetryEvent = true;
               await delay2(delayMs, params.config?.abortSignal).promise;
               continue;
@@ -38190,6 +38413,8 @@ var GeminiChat = class {
                 retryDecision: streamYieldedContentChunk ? "skipped_after_content" : "exhausted",
                 attempts: transportStreamRetryCount,
                 maxRetries: TRANSPORT_STREAM_RETRY_CONFIG.maxRetries,
+                continuationAttempts: transportContinuationCount,
+                maxContinuationRetries: TRANSPORT_STREAM_RETRY_CONFIG.maxContinuationRetries,
                 errorKind: classification.kind,
                 transportCode: classification.transportCode
               });
@@ -38209,6 +38434,7 @@ var GeminiChat = class {
                     params.config?.abortSignal,
                     {
                       originalTokenCountOverride: reactiveOriginalTokenCount,
+                      requestGenerationConfig: params.config,
                       trigger: "auto"
                     }
                   );
@@ -38244,6 +38470,7 @@ var GeminiChat = class {
                       info: reactiveInfo
                     };
                     yield { type: "retry" /* RETRY */ };
+                    resetTransportContinuation();
                     suppressNextRetryEvent = true;
                     continue;
                   }
@@ -38612,7 +38839,7 @@ var GeminiChat = class {
                     fallbackRetryErrorCodes,
                     turnGoalContext
                   )) {
-                    const emittedUserVisibleOutput = event.type !== "chunk" /* CHUNK */ || !isToolCallPreparationOnly(event.value);
+                    const emittedUserVisibleOutput = event.type !== "chunk" /* CHUNK */ || hasCandidateOutput(event.value);
                     if (emittedUserVisibleOutput) {
                       currentFallbackYieldedAnyChunk = true;
                       fallbackStreamYieldedAnyChunk = true;
@@ -39096,6 +39323,21 @@ This error was probably caused by cyclic schema references in one of the followi
     let hasToolCall = false;
     let hasFinishReason = false;
     const protocolTagDetector = new LeadingProtocolTagLeakDetector();
+    let pendingProtocolParts = [];
+    const takePendingProtocolParts = /* @__PURE__ */ __name(() => {
+      const parts = pendingProtocolParts;
+      pendingProtocolParts = [];
+      const released = [];
+      for (const part of parts) {
+        const previous = released.at(-1);
+        if (previous && isValidNonThoughtTextPart(previous) && isValidNonThoughtTextPart(part)) {
+          previous.text += part.text;
+        } else {
+          released.push(isValidNonThoughtTextPart(part) ? { ...part } : part);
+        }
+      }
+      return released;
+    }, "takePendingProtocolParts");
     let protocolTextWasSuppressed = false;
     const currentUserTurn = this.history[this.history.length - 1];
     const isToolResultContinuation = currentUserTurn?.role === "user" && currentUserTurn.parts?.some((part) => part.functionResponse) === true;
@@ -39120,22 +39362,57 @@ This error was probably caused by cyclic schema references in one of the followi
         hasFinishReason ||= chunk?.candidates?.some((candidate) => candidate.finishReason) ?? false;
         if (isValidResponse(chunk)) {
           const candidate = chunk.candidates?.[0];
-          const content = candidate?.content;
+          let content = candidate?.content;
+          if (candidate?.finishReason && !content?.parts) {
+            protocolTagDetector.finish();
+            if (protocolTagDetector.leaked) {
+              pendingProtocolParts = [];
+            } else {
+              const parts = takePendingProtocolParts();
+              if (parts.length > 0) {
+                content = {
+                  ...content,
+                  role: content?.role ?? "model",
+                  parts
+                };
+                candidate.content = content;
+              }
+            }
+          }
           if (content?.parts) {
-            content.parts = content.parts.flatMap((part) => {
+            const outputParts = [];
+            for (const part of content.parts) {
               if (isToolResultContinuation && !part.thought && part.text?.trim() === GEMINI_EMPTY_CONTENT_PLACEHOLDER) {
-                return [];
+                continue;
+              }
+              if (typeof part.text !== "string" || part.thought) {
+                if (pendingProtocolParts.length > 0 || protocolTagDetector.leaked) {
+                  pendingProtocolParts.push(part);
+                } else {
+                  outputParts.push(part);
+                }
+                continue;
               }
-              if (typeof part.text !== "string" || part.thought) return [part];
               const text = protocolTagDetector.accept(part.text);
-              if (text) return [{ ...part, text }];
+              if (text) {
+                if (pendingProtocolParts.length > 0) {
+                  outputParts.push(...takePendingProtocolParts(), part);
+                } else {
+                  outputParts.push({ ...part, text });
+                }
+                continue;
+              }
+              pendingProtocolParts.push(...outputParts.splice(0), part);
               protocolTextWasSuppressed ||= part.text.length > 0;
-              const { text: _text, ...rest } = part;
-              return Object.values(rest).some((value) => value !== void 0) ? [rest] : [];
-            });
+            }
+            content.parts = outputParts;
             if (candidate?.finishReason) {
-              const text = protocolTagDetector.finish();
-              if (text) content.parts.push({ text });
+              protocolTagDetector.finish();
+              if (protocolTagDetector.leaked) {
+                pendingProtocolParts = [];
+              } else {
+                content.parts.push(...takePendingProtocolParts());
+              }
             }
             content.parts = normalizeModelToolCallIds(
               content.parts,
@@ -39208,13 +39485,33 @@ This error was probably caused by cyclic schema references in one of the followi
             }
           }
         }
-        if (!protocolTextWasSuppressed || !protocolTagDetector.blockingOutput) {
+        if (!chunk.candidates?.length || preparations.length > 0 || !protocolTextWasSuppressed || !protocolTagDetector.blockingOutput) {
           yield chunk;
         }
       }
     } catch (e) {
       streamError = e;
     }
+    if (streamError === null && pendingProtocolParts.length > 0 && (hasToolCall || pendingProtocolParts.some((part) => part.functionCall !== void 0))) {
+      protocolTagDetector.finish();
+      if (protocolTagDetector.leaked) {
+        pendingProtocolParts = [];
+      } else {
+        const parts = normalizeModelToolCallIds(
+          takePendingProtocolParts(),
+          usedToolCallIds,
+          rawToolCallIdsInCurrentTurn,
+          reservedToolCallIds
+        );
+        const chunk = {
+          candidates: [{ content: { role: "model", parts } }]
+        };
+        syncFunctionCallsField(chunk, parts);
+        hasToolCall ||= parts.some((part) => part.functionCall);
+        allModelParts.push(...parts);
+        yield chunk;
+      }
+    }
     let thoughtContentPart;
     const thoughtText = allModelParts.filter((part) => part.thought).map((part) => part.text).join("").trim();
     if (thoughtText !== "") {
@@ -39283,7 +39580,7 @@ This error was probably caused by cyclic schema references in one of the followi
         );
       }
     }
-    if (streamError === null && protocolTagDetector.leaked) {
+    if (streamError === null && protocolTagDetector.leaked && !hasToolCall) {
       throw new InvalidStreamError(
         "Model response started with leaked protocol tags.",
         "PROTOCOL_TAG_LEAK"
@@ -39364,6 +39661,49 @@ This error was probably caused by cyclic schema references in one of the followi
       };
     }
   }
+  /**
+   * Prepend already-delivered text to the trailing model turn.
+   *
+   * Used by the transport-continuation path (issue #7832): after a socket cut
+   * mid-response, the caller has seen text that `processStreamResponse`
+   * deliberately did not persist, and the continuation attempt's own turn
+   * carries only the resumed remainder. Without this, durable history would
+   * hold an answer that starts mid-sentence — visibly wrong on `/compress`,
+   * `--resume`, and every later turn's context.
+   *
+   * The delivered text is merged into the turn's first plain-text part (kept
+   * after any leading thought part, matching the
+   * `[thoughtPart?, ...text]` shape `processStreamResponse` produces), or
+   * inserted as a new part when the continuation returned no text of its own.
+   * Overlap is deduped by the same helper the output-recovery merge uses, so a
+   * model that replays part of its previous tail does not double it.
+   */
+  prependTextToLastModelTurn(deliveredText) {
+    if (deliveredText.length === 0) return;
+    const lastEntry = this.history.at(-1);
+    if (lastEntry?.role !== "model") {
+      debugLogger22.warn(
+        "[TRANSPORT_CONTINUATION] Trailing entry is not a model turn; dropping the delivered-text merge.",
+        { role: lastEntry?.role ?? "undefined" }
+      );
+      return;
+    }
+    const parts = [...lastEntry.parts ?? []];
+    const textIndex = parts.findIndex(isPlainTextPart);
+    if (textIndex < 0) {
+      const insertAt = parts.findIndex((part) => !part.thought);
+      parts.splice(insertAt < 0 ? parts.length : insertAt, 0, {
+        text: deliveredText
+      });
+    } else {
+      const continuationPart = parts[textIndex];
+      parts[textIndex] = {
+        ...continuationPart,
+        text: deliveredText + getRecoveryContinuationSuffix(deliveredText, continuationPart.text)
+      };
+    }
+    lastEntry.parts = parts;
+  }
   /**
    * Merge `pairCount` trailing (user_recovery, model_continuation) pairs back
    * into the model turn that precedes them. Used after the output-token
@@ -84989,7 +85329,7 @@ async function runManagedRememberByAgent(params) {
       wrapUserContent: true
     }),
     systemPrompt: buildRememberSystemPrompt(memoryPrompt),
-    maxTurns: 6,
+    maxTurns: params.config.getMemoryAgentMaxTurns() ?? 6,
     maxTimeMinutes: params.config.getMemoryAgentTimeoutMinutes() ?? 5,
     extraHistory: params.contextMode === "clean" ? [] : void 0,
     preserveEmptyExtraHistory: params.contextMode === "clean",
@@ -85235,7 +85575,7 @@ async function planManagedAutoMemoryDreamByAgent(config, projectRoot, abortSigna
     config: scopedConfig,
     taskPrompt: buildConsolidationTaskPrompt(memoryRoot, transcriptDir),
     systemPrompt: DREAM_AGENT_SYSTEM_PROMPT,
-    maxTurns: MAX_TURNS,
+    maxTurns: config.getMemoryAgentMaxTurns() ?? MAX_TURNS,
     maxTimeMinutes: config.getMemoryAgentTimeoutMinutes() ?? MAX_TIME_MINUTES,
     tools: [
       ToolNames.READ_FILE,
@@ -85616,7 +85956,7 @@ async function runSkillReviewByAgent(params) {
     config: scopedConfig,
     taskPrompt: await buildTaskPrompt(params.projectRoot),
     systemPrompt: SKILL_REVIEW_SYSTEM_PROMPT,
-    maxTurns: params.maxTurns ?? DEFAULT_AUTO_SKILL_MAX_TURNS,
+    maxTurns: params.maxTurns ?? params.config.getMemoryAgentMaxTurns() ?? DEFAULT_AUTO_SKILL_MAX_TURNS,
     maxTimeMinutes: params.timeoutMs !== void 0 ? params.timeoutMs / 6e4 : params.config.getMemoryAgentTimeoutMinutes() ?? DEFAULT_AUTO_SKILL_TIMEOUT_MS / 6e4,
     tools: [
       ToolNames.READ_FILE,
@@ -138860,7 +139200,7 @@ async function runAutoMemoryExtractionByAgent(config, projectRoot) {
       topicSummaries
     ),
     systemPrompt: EXTRACTION_AGENT_SYSTEM_PROMPT,
-    maxTurns: 5,
+    maxTurns: config.getMemoryAgentMaxTurns() ?? 5,
     maxTimeMinutes: config.getMemoryAgentTimeoutMinutes() ?? 2,
     tools: [
       ToolNames.READ_FILE,
@@ -142242,7 +142582,6 @@ var GeminiClient = class _GeminiClient {
           skillsModified: this.skillsModifiedInSession,
           enabled: autoSkillEnabled,
           threshold: AUTO_SKILL_THRESHOLD,
-          maxTurns: DEFAULT_AUTO_SKILL_MAX_TURNS,
           confirmBeforePersist: this.config.getAutoSkillConfirmEnabled()
         });
         if (skillReviewResult.status === "scheduled") {
@@ -145613,6 +145952,7 @@ var Config = class _Config {
   enableAutoSkill;
   autoSkillConfirm;
   memoryAgentTimeoutMinutes;
+  memoryAgentMaxTurns;
   fastModel;
   webSearchSettings;
   webSearchNoticeEmitted = false;
@@ -145928,6 +146268,7 @@ var Config = class _Config {
     this.enableAutoSkill = params.enableAutoSkill ?? false;
     this.autoSkillConfirm = params.autoSkillConfirm ?? true;
     this.memoryAgentTimeoutMinutes = params.memoryAgentTimeoutMinutes !== void 0 && params.memoryAgentTimeoutMinutes >= 0 ? params.memoryAgentTimeoutMinutes : void 0;
+    this.memoryAgentMaxTurns = params.memoryAgentMaxTurns !== void 0 && Number.isInteger(params.memoryAgentMaxTurns) && params.memoryAgentMaxTurns >= 0 ? params.memoryAgentMaxTurns : void 0;
     this.fastModel = params.fastModel || void 0;
     this.webSearchSettings = params.webSearch;
     this.visionModel = params.visionModel || void 0;
@@ -149243,6 +149584,14 @@ var Config = class _Config {
   getMemoryAgentTimeoutMinutes() {
     return this.memoryAgentTimeoutMinutes;
   }
+  /**
+   * Max turns for background memory agents. Resolves the
+   * `memory.agentMaxTurns` setting. Unset means each agent's built-in default;
+   * 0 disables the turn limit.
+   */
+  getMemoryAgentMaxTurns() {
+    return this.memoryAgentMaxTurns;
+  }
   getPreventSystemSleepEnabled() {
     return this.preventSystemSleep && !this.isSafeMode();
   }
@@ -149982,7 +150331,7 @@ var Config = class _Config {
     }
     if (!enabled) return;
     registry.registerFactory(ToolNames.IMAGE_GEN, async () => {
-      const { ImageGenTool } = await import("./image-gen-UC7XVHI7.js");
+      const { ImageGenTool } = await import("./image-gen-2ZWPS42A.js");
       return new ImageGenTool(this);
     });
   }
@@ -150029,19 +150378,19 @@ var Config = class _Config {
     }, "registerGoalWorkerTools");
     if (this.getBareMode()) {
       await registerLazy(ToolNames.READ_FILE, async () => {
-        const { ReadFileTool } = await import("./read-file-HXJXHBI6.js");
+        const { ReadFileTool } = await import("./read-file-2T54FYZV.js");
         return new ReadFileTool(this);
       });
       await registerLazy(ToolNames.EDIT, async () => {
-        const { EditTool } = await import("./edit-J7SW6UP6.js");
+        const { EditTool } = await import("./edit-YK3UP6D2.js");
         return new EditTool(this);
       });
       await registerLazy(ToolNames.NOTEBOOK_EDIT, async () => {
-        const { NotebookEditTool } = await import("./notebook-edit-EZISE7IC.js");
+        const { NotebookEditTool } = await import("./notebook-edit-373IQQLE.js");
         return new NotebookEditTool(this);
       });
       await registerLazy(ToolNames.SHELL, async () => {
-        const { ShellTool: ShellTool2 } = await import("./shell-GLC6OP3C.js");
+        const { ShellTool: ShellTool2 } = await import("./shell-RT5DBH6B.js");
         return new ShellTool2(this);
       });
       await registerGoalWorkerTools();
@@ -150053,7 +150402,7 @@ var Config = class _Config {
     }
     await registerGoalWorkerTools();
     await registerLazy(ToolNames.TOOL_SEARCH, async () => {
-      const { ToolSearchTool } = await import("./tool-search-DEAS54VG.js");
+      const { ToolSearchTool } = await import("./tool-search-2AOU77H4.js");
       return new ToolSearchTool(this);
     });
     await registerLazy(ToolNames.READ_MCP_RESOURCE, async () => {
@@ -150061,7 +150410,7 @@ var Config = class _Config {
       return new ReadMcpResourceTool(this);
     });
     await registerLazy(ToolNames.AGENT, async () => {
-      const { AgentTool: AgentTool2 } = await import("./agent-PE37ARLM.js");
+      const { AgentTool: AgentTool2 } = await import("./agent-RB6LCRZX.js");
       return new AgentTool2(this);
     });
     await registerLazy(ToolNames.LIST_AGENTS, async () => {
@@ -150073,11 +150422,11 @@ var Config = class _Config {
       return new TaskStopTool(this);
     });
     await registerLazy(ToolNames.SEND_MESSAGE, async () => {
-      const { SendMessageTool } = await import("./send-message-HGCVVDTZ.js");
+      const { SendMessageTool } = await import("./send-message-LHJLVWFD.js");
       return new SendMessageTool(this);
     });
     await registerLazy(ToolNames.SKILL, async () => {
-      const { SkillTool } = await import("./skill-C7W6M4GO.js");
+      const { SkillTool } = await import("./skill-LVGA3ATZ.js");
       return new SkillTool(this);
     });
     await registerLazy(ToolNames.LS, async () => {
@@ -150085,11 +150434,11 @@ var Config = class _Config {
       return new LSTool(this);
     });
     await registerLazy(ToolNames.READ_FILE, async () => {
-      const { ReadFileTool } = await import("./read-file-HXJXHBI6.js");
+      const { ReadFileTool } = await import("./read-file-2T54FYZV.js");
       return new ReadFileTool(this);
     });
     await registerLazy(ToolNames.ZOOM_IMAGE, async () => {
-      const { ZoomImageTool } = await import("./zoom-image-O5YCB7WN.js");
+      const { ZoomImageTool } = await import("./zoom-image-E3VHRCFU.js");
       return new ZoomImageTool(this);
     });
     if (this.getUseRipgrep()) {
@@ -150104,7 +150453,7 @@ var Config = class _Config {
       recordStartupEvent("config_initialize_ripgrep_probe_end");
       if (useRipgrep) {
         await registerLazy(ToolNames.GREP, async () => {
-          const { RipGrepTool: RipGrepTool2 } = await import("./ripGrep-MCETPF2E.js");
+          const { RipGrepTool: RipGrepTool2 } = await import("./ripGrep-3H72KY7S.js");
           return new RipGrepTool2(this);
         });
       } else {
@@ -150117,7 +150466,7 @@ var Config = class _Config {
           )
         );
         await registerLazy(ToolNames.GREP, async () => {
-          const { GrepTool } = await import("./grep-UJMPVZER.js");
+          const { GrepTool } = await import("./grep-SQ7RD7SV.js");
           return new GrepTool(this);
         });
       }
@@ -150125,32 +150474,32 @@ var Config = class _Config {
       recordStartupEvent("config_initialize_ripgrep_probe_start");
       recordStartupEvent("config_initialize_ripgrep_probe_end");
       await registerLazy(ToolNames.GREP, async () => {
-        const { GrepTool } = await import("./grep-UJMPVZER.js");
+        const { GrepTool } = await import("./grep-SQ7RD7SV.js");
         return new GrepTool(this);
       });
     }
     await registerLazy(ToolNames.GLOB, async () => {
-      const { GlobTool } = await import("./glob-F3EAUDAX.js");
+      const { GlobTool } = await import("./glob-SKUYGTF2.js");
       return new GlobTool(this);
     });
     await registerLazy(ToolNames.EDIT, async () => {
-      const { EditTool } = await import("./edit-J7SW6UP6.js");
+      const { EditTool } = await import("./edit-YK3UP6D2.js");
       return new EditTool(this);
     });
     await registerLazy(ToolNames.NOTEBOOK_EDIT, async () => {
-      const { NotebookEditTool } = await import("./notebook-edit-EZISE7IC.js");
+      const { NotebookEditTool } = await import("./notebook-edit-373IQQLE.js");
       return new NotebookEditTool(this);
     });
     await registerLazy(ToolNames.WRITE_FILE, async () => {
-      const { WriteFileTool: WriteFileTool2 } = await import("./write-file-RQ4DG5RY.js");
+      const { WriteFileTool: WriteFileTool2 } = await import("./write-file-MOM4JDHG.js");
       return new WriteFileTool2(this);
     });
     await registerLazy(ToolNames.SHELL, async () => {
-      const { ShellTool: ShellTool2 } = await import("./shell-GLC6OP3C.js");
+      const { ShellTool: ShellTool2 } = await import("./shell-RT5DBH6B.js");
       return new ShellTool2(this);
     });
     await registerLazy(ToolNames.TODO_WRITE, async () => {
-      const { TodoWriteTool } = await import("./todoWrite-YKAA57W2.js");
+      const { TodoWriteTool } = await import("./todoWrite-FTZWQRZH.js");
       return new TodoWriteTool(this);
     });
     const supportsUserInteraction = resolveInteractionMode(this) !== "headless";
@@ -150162,40 +150511,40 @@ var Config = class _Config {
     }
     if (!this.sdkMode && (supportsUserInteraction || options2?.forSubAgent)) {
       await registerLazy(ToolNames.EXIT_PLAN_MODE, async () => {
-        const { ExitPlanModeTool: ExitPlanModeTool2 } = await import("./exitPlanMode-4ZFY7KUH.js");
+        const { ExitPlanModeTool: ExitPlanModeTool2 } = await import("./exitPlanMode-K5Y3REU2.js");
         return new ExitPlanModeTool2(this);
       });
     }
     if (!this.sdkMode && supportsUserInteraction) {
       await registerLazy(ToolNames.ENTER_PLAN_MODE, async () => {
-        const { EnterPlanModeTool } = await import("./enterPlanMode-GDSTEFSM.js");
+        const { EnterPlanModeTool } = await import("./enterPlanMode-TZAYQ5MP.js");
         return new EnterPlanModeTool(this);
       });
     }
     await registerLazy(ToolNames.ENTER_WORKTREE, async () => {
-      const { EnterWorktreeTool } = await import("./enter-worktree-NRLOHRB6.js");
+      const { EnterWorktreeTool } = await import("./enter-worktree-QMVQW7UG.js");
       return new EnterWorktreeTool(this);
     });
     await registerLazy(ToolNames.EXIT_WORKTREE, async () => {
-      const { ExitWorktreeTool } = await import("./exit-worktree-ARVID7DF.js");
+      const { ExitWorktreeTool } = await import("./exit-worktree-4EC7LBBC.js");
       return new ExitWorktreeTool(this);
     });
     await registerLazy(ToolNames.WEB_FETCH, async () => {
-      const { WebFetchTool } = await import("./web-fetch-Y5QQMPKA.js");
+      const { WebFetchTool } = await import("./web-fetch-ZRXSV5AN.js");
       return new WebFetchTool(this);
     });
     if (resolveInteractionMode(this) === "interactive" && !this.sdkMode && !this.getScreenReader() && !options2?.forSubAgent) {
       await registerLazy(ToolNames.DISPLAY_IMAGE, async () => {
-        const { DisplayImageTool } = await import("./display-image-VS3TXYQH.js");
+        const { DisplayImageTool } = await import("./display-image-2WOG27DY.js");
         return new DisplayImageTool(this);
       });
     }
     if (this.webSearchSettings?.enabled) {
-      const { evaluateWebSearchGate } = await import("./web-search-QKKEU723.js");
+      const { evaluateWebSearchGate } = await import("./web-search-WOLV3L6T.js");
       const gate = evaluateWebSearchGate(this);
       if (gate.ok) {
         await registerLazy(ToolNames.WEB_SEARCH, async () => {
-          const { WebSearchTool } = await import("./web-search-QKKEU723.js");
+          const { WebSearchTool } = await import("./web-search-WOLV3L6T.js");
           return new WebSearchTool(this);
         });
       } else if (!this.webSearchNoticeEmitted && !options2?.forSubAgent) {
@@ -150247,7 +150596,7 @@ var Config = class _Config {
     });
     if (this.isAgentTeamEnabled()) {
       await registerLazy(ToolNames.TEAM_CREATE, async () => {
-        const { TeamCreateTool } = await import("./team-create-HBIJ7NHT.js");
+        const { TeamCreateTool } = await import("./team-create-ZVPQIXCP.js");
         return new TeamCreateTool(this);
       });
       await registerLazy(ToolNames.TEAM_DELETE, async () => {
@@ -150255,15 +150604,15 @@ var Config = class _Config {
         return new TeamDeleteTool(this);
       });
       await registerLazy(ToolNames.TEAM_PLAN_APPROVAL, async () => {
-        const { TeamPlanApprovalTool } = await import("./team-plan-approval-IBJOKS4J.js");
+        const { TeamPlanApprovalTool } = await import("./team-plan-approval-5UHUBY3W.js");
         return new TeamPlanApprovalTool(this);
       });
       await registerLazy(ToolNames.TASK_CREATE, async () => {
-        const { TaskCreateTool } = await import("./task-create-CSCEG4SM.js");
+        const { TaskCreateTool } = await import("./task-create-4ALZMGP5.js");
         return new TaskCreateTool(this);
       });
       await registerLazy(ToolNames.TASK_UPDATE, async () => {
-        const { TaskUpdateTool } = await import("./task-update-C52LNFU5.js");
+        const { TaskUpdateTool } = await import("./task-update-IKCEEWJ6.js");
         return new TaskUpdateTool(this);
       });
       await registerLazy(ToolNames.TASK_LIST, async () => {
@@ -150273,16 +150622,16 @@ var Config = class _Config {
     }
     if (this.isWorkflowsEnabled()) {
       await registerLazy(ToolNames.WORKFLOW, async () => {
-        const { WorkflowTool } = await import("./workflow-PWIU6Q2M.js");
+        const { WorkflowTool } = await import("./workflow-F63ES3OB.js");
         return new WorkflowTool(this);
       });
     }
     if (this.isComputerUseEnabled()) {
-      const { registerComputerUseTools } = await import("./computer-use-UJMK6JQU.js");
+      const { registerComputerUseTools } = await import("./computer-use-MDOMIVTL.js");
       await registerComputerUseTools(registerLazy, this);
     }
     await registerLazy(ToolNames.MONITOR, async () => {
-      const { MonitorTool } = await import("./monitor-TGSVSAZZ.js");
+      const { MonitorTool } = await import("./monitor-6Y3NDMTI.js");
       return new MonitorTool(this);
     });
     if (this.pendingMcpBudgetCallback) {