@qwen-code/qwen-code 0.16.0 → 0.16.1-nightly.20260524.84f408017

package/chunks/{chunk-3T4ZT63H.js → chunk-6JQC5PYU.js}

@@ -159,7 +159,7 @@ import {
   truncateSpanError,
   truncateToolOutput,
   uiTelemetryService
-} from "./chunk-WCZWAKFG.js";
+} from "./chunk-JUAMIT3V.js";
 import {
   DEFAULT_QWEN_EMBEDDING_MODEL,
   DEFAULT_QWEN_MODEL
@@ -35751,6 +35751,128 @@ var InvalidStreamError = class extends Error {
     this.type = type;
   }
 };
+var ORPHAN_TOOL_USE_REPAIR_REASON = "Tool execution result was not recorded \u2014 likely interrupted by network failure, abort, or process exit. Treat as failure and retry if needed.";
+function scanModelTurn(history, modelIdx) {
+  const expected = /* @__PURE__ */ new Map();
+  for (const part of history[modelIdx]?.parts ?? []) {
+    const fc = part.functionCall;
+    if (fc?.id) expected.set(fc.id, fc.name ?? "unknown");
+  }
+  const matched = /* @__PURE__ */ new Map();
+  let scanIdx = modelIdx + 1;
+  while (scanIdx < history.length && history[scanIdx]?.role === "user") {
+    const parts2 = history[scanIdx].parts ?? [];
+    for (let pIdx = 0; pIdx < parts2.length; pIdx++) {
+      const part = parts2[pIdx];
+      const id = part.functionResponse?.id;
+      if (id) {
+        const list3 = matched.get(id);
+        if (list3) list3.push({ turnIdx: scanIdx, partIdx: pIdx, part });
+        else matched.set(id, [{ turnIdx: scanIdx, partIdx: pIdx, part }]);
+      }
+    }
+    scanIdx++;
+  }
+  return { modelIdx, expected, matched, scanEnd: scanIdx };
+}
+__name(scanModelTurn, "scanModelTurn");
+function planRepair(scan) {
+  const synthesizeIds = [];
+  const hoistedParts = [];
+  const removalTargets = [];
+  const droppedDuplicates = [];
+  const adjacentIdx = scan.modelIdx + 1;
+  for (const [id, name3] of scan.expected) {
+    const locations = scan.matched.get(id);
+    if (!locations || locations.length === 0) {
+      synthesizeIds.push([id, name3]);
+      continue;
+    }
+    const survivor = locations[0];
+    if (survivor.turnIdx !== adjacentIdx) {
+      hoistedParts.push(survivor.part);
+      removalTargets.push({
+        turnIdx: survivor.turnIdx,
+        partIdx: survivor.partIdx
+      });
+    }
+    for (let k = 1; k < locations.length; k++) {
+      removalTargets.push({
+        turnIdx: locations[k].turnIdx,
+        partIdx: locations[k].partIdx
+      });
+      droppedDuplicates.push({ callId: id, name: name3 });
+    }
+  }
+  return {
+    modelIdx: scan.modelIdx,
+    scanEnd: scan.scanEnd,
+    synthesizeIds,
+    hoistedParts,
+    removalTargets,
+    droppedDuplicates
+  };
+}
+__name(planRepair, "planRepair");
+function applyRepair(history, plan, reason) {
+  if (plan.synthesizeIds.length === 0 && plan.removalTargets.length === 0) {
+    return { insertedBefore: 0 };
+  }
+  const syntheticParts = plan.synthesizeIds.map(([callId, name3]) => ({
+    functionResponse: { id: callId, name: name3, response: { error: reason } }
+  }));
+  const partsToInject = [...syntheticParts, ...plan.hoistedParts];
+  const removals = [...plan.removalTargets].sort((a, b) => {
+    if (a.turnIdx !== b.turnIdx) return b.turnIdx - a.turnIdx;
+    return b.partIdx - a.partIdx;
+  });
+  for (const loc of removals) {
+    const turnParts = history[loc.turnIdx].parts;
+    if (turnParts) turnParts.splice(loc.partIdx, 1);
+  }
+  const adjacentIdx = plan.modelIdx + 1;
+  for (let j = plan.scanEnd - 1; j > adjacentIdx; j--) {
+    if (history[j]?.role === "user" && (history[j].parts?.length ?? 0) === 0) {
+      history.splice(j, 1);
+    }
+  }
+  const next = history[adjacentIdx];
+  if (next?.role === "user") {
+    const existing = next.parts ?? [];
+    const firstNonFr = existing.findIndex((part) => !part.functionResponse);
+    const insertAt = firstNonFr === -1 ? existing.length : firstNonFr;
+    next.parts = [
+      ...existing.slice(0, insertAt),
+      ...partsToInject,
+      ...existing.slice(insertAt)
+    ];
+    return { insertedBefore: 0 };
+  }
+  history.splice(adjacentIdx, 0, { role: "user", parts: partsToInject });
+  return { insertedBefore: 1 };
+}
+__name(applyRepair, "applyRepair");
+function repairOrphanedToolUseTurns(history, reason = ORPHAN_TOOL_USE_REPAIR_REASON) {
+  const injected = [];
+  const droppedDuplicates = [];
+  for (let i2 = 0; i2 < history.length; i2++) {
+    if (history[i2].role !== "model") continue;
+    const scan = scanModelTurn(history, i2);
+    if (scan.expected.size === 0) continue;
+    const plan = planRepair(scan);
+    if (plan.synthesizeIds.length === 0 && plan.removalTargets.length === 0) {
+      continue;
+    }
+    const { insertedBefore } = applyRepair(history, plan, reason);
+    for (const [callId, name3] of plan.synthesizeIds) {
+      injected.push({ callId, name: name3 });
+    }
+    droppedDuplicates.push(...plan.droppedDuplicates);
+    i2 += insertedBefore;
+  }
+  return { injected, droppedDuplicates };
+}
+__name(repairOrphanedToolUseTurns, "repairOrphanedToolUseTurns");
 var SESSION_START_CONTEXT_SENTINEL_START = '<qwen:session-start-context hidden="true">';
 var SESSION_START_CONTEXT_SENTINEL_END = "</qwen:session-start-context>";
 var SESSION_START_CONTEXT_HEADER = "SessionStart additional context";
@@ -35826,6 +35948,23 @@ var GeminiChat = class {
    * in a loop. Manual `/compress` still works (it passes `force=true`).
    */
   hasFailedCompressionAttempt = false;
+  /**
+   * Partial-push markers — index of the in-memory `model[partial fc]`
+   * and the matching deferred JSONL record. See the canonical note
+   * above `ORPHAN_TOOL_USE_REPAIR_REASON` for the lifecycle and the
+   * wedge they prevent.
+   */
+  pendingPartialAssistantTurnIndex = null;
+  pendingPartialAssistantRecord = null;
+  /**
+   * Reset both partial-push markers in lockstep. Every history-mutation
+   * site uses this — single-field resets are a bug because the fields
+   * are always paired by lifecycle.
+   */
+  clearPendingPartialState() {
+    this.pendingPartialAssistantTurnIndex = null;
+    this.pendingPartialAssistantRecord = null;
+  }
   /**
    * Most recent prompt-token count reported by the model for *this* chat,
    * mirroring the value in {@link UiTelemetryService} for the main session.
@@ -35951,6 +36090,7 @@ var GeminiChat = class {
       streamDoneResolver = resolve30;
     });
     this.sendPromise = streamDonePromise;
+    this.clearPendingPartialState();
     let compressionInfo;
     let requestContents;
     let userContentAdded = false;
@@ -35964,6 +36104,17 @@ var GeminiChat = class {
       const userContent = createUserContent(params.message);
       this.history.push(userContent);
       userContentAdded = true;
+      const inlineRepair = repairOrphanedToolUseTurns(this.history);
+      if (inlineRepair.injected.length > 0) {
+        debugLogger15.warn(
+          `[REPAIR] sendMessageStream inline pass synthesized ${inlineRepair.injected.length} functionResponse(s): ` + inlineRepair.injected.map((entry) => `${entry.name}(${entry.callId})`).join(", ")
+        );
+      }
+      if (inlineRepair.droppedDuplicates.length > 0) {
+        debugLogger15.warn(
+          `[REPAIR] sendMessageStream inline pass dropped ${inlineRepair.droppedDuplicates.length} duplicate functionResponse(s): ` + inlineRepair.droppedDuplicates.map((entry) => `${entry.name}(${entry.callId})`).join(", ")
+        );
+      }
       requestContents = this.getRequestHistory();
     } catch (error) {
       if (userContentAdded) {
@@ -36015,8 +36166,21 @@ var GeminiChat = class {
             break;
           } catch (error) {
             lastError = error;
+            const popPartialIfPushed = /* @__PURE__ */ __name(() => {
+              const idx = self2.pendingPartialAssistantTurnIndex;
+              if (idx === null) return;
+              if (self2.history.length > idx && self2.history[idx]?.role === "model") {
+                self2.history.splice(idx, 1);
+              } else {
+                debugLogger15.warn(
+                  `[PARTIAL_POP] Splice skipped: idx=${idx}, historyLength=${self2.history.length}, roleAtIdx=${self2.history[idx]?.role ?? "undefined"}`
+                );
+              }
+              self2.clearPendingPartialState();
+            }, "popPartialIfPushed");
             const isRateLimit = isRateLimitError(error, extraRetryErrorCodes);
             if (isRateLimit && rateLimitRetryCount < maxRateLimitRetries) {
+              popPartialIfPushed();
               rateLimitRetryCount++;
               const delayMs = getRateLimitRetryDelayMs(rateLimitRetryCount, {
                 ...RATE_LIMIT_RETRY_OPTIONS,
@@ -36081,6 +36245,7 @@ var GeminiChat = class {
                     }
                   );
                   if (reactiveInfo.compressionStatus === 1 /* COMPRESSED */) {
+                    popPartialIfPushed();
                     requestContents = self2.getRequestHistory();
                     debugLogger15.info(
                       `Reactive compression succeeded: ${reactiveInfo.originalTokenCount} -> ${reactiveInfo.newTokenCount} tokens.`
@@ -36118,6 +36283,7 @@ var GeminiChat = class {
             }
             const isTransientStreamError = error instanceof InvalidStreamError;
             if (isTransientStreamError && invalidStreamRetryCount < INVALID_STREAM_RETRY_CONFIG.maxRetries) {
+              popPartialIfPushed();
               invalidStreamRetryCount++;
               const delayMs = INVALID_STREAM_RETRY_CONFIG.initialDelayMs * invalidStreamRetryCount;
               debugLogger15.warn(
@@ -36143,6 +36309,7 @@ var GeminiChat = class {
             const isContentError = error instanceof InvalidStreamError;
             if (isContentError) {
               if (attempt < INVALID_CONTENT_RETRY_OPTIONS.maxAttempts - 1) {
+                popPartialIfPushed();
                 logContentRetry(
                   self2.config,
                   new ContentRetryEvent(
@@ -36231,6 +36398,17 @@ var GeminiChat = class {
               }
               successfulRecoveries++;
             } catch (recoveryError) {
+              const expectedIdx = self2.pendingPartialAssistantTurnIndex;
+              const lastIdx = self2.history.length - 1;
+              if (expectedIdx !== null && self2.history.length > 0 && self2.history[lastIdx]?.role === "model") {
+                if (expectedIdx !== lastIdx) {
+                  debugLogger15.warn(
+                    `[RECOVERY_POP] Marker/last-index mismatch: marker=${expectedIdx}, lastIdx=${lastIdx}, historyLength=${self2.history.length}. Popping last entry as best-effort rollback \u2014 investigate any history mutation between processStreamResponse's partial push and this catch.`
+                  );
+                }
+                self2.history.pop();
+                self2.clearPendingPartialState();
+              }
               if (self2.history.length > 0 && self2.history[self2.history.length - 1].role === "user") {
                 self2.history.pop();
               }
@@ -36271,6 +36449,18 @@ var GeminiChat = class {
         }
       } finally {
         streamDoneResolver();
+        if (self2.pendingPartialAssistantRecord) {
+          try {
+            self2.chatRecordingService?.recordAssistantTurn(
+              self2.pendingPartialAssistantRecord
+            );
+          } catch (recordErr) {
+            debugLogger15.error(
+              "[PARTIAL_FLUSH] Failed to persist deferred JSONL record: " + (recordErr instanceof Error ? recordErr.message : String(recordErr))
+            );
+          }
+          self2.clearPendingPartialState();
+        }
       }
     }();
   }
@@ -36399,26 +36589,53 @@ var GeminiChat = class {
   getHistoryLength() {
     return this.history.length;
   }
+  /**
+   * Set of `functionResponse.id` strings in user turns. Walk-only,
+   * no clone — `useGeminiStream.handleCompletedTools` calls this per
+   * tool-completion batch, so {@link getHistory}'s `structuredClone`
+   * would stall the UI on long sessions.
+   */
+  getHistoryFunctionResponseIds() {
+    const ids = /* @__PURE__ */ new Set();
+    for (const entry of this.history) {
+      if (entry.role !== "user") continue;
+      for (const part of entry.parts ?? []) {
+        const id = part.functionResponse?.id;
+        if (id) ids.add(id);
+      }
+    }
+    return ids;
+  }
   /**
    * Clears the chat history.
    */
   clearHistory() {
     this.history = [];
+    this.clearPendingPartialState();
   }
   /**
    * Adds a new entry to the chat history.
    */
   addHistory(content) {
     this.history.push(content);
+    if (this.pendingPartialAssistantTurnIndex !== null || this.pendingPartialAssistantRecord !== null) {
+      debugLogger15.error(
+        "[INVARIANT_VIOLATION] addHistory called while a partial-push marker is active \u2014 clearing it."
+      );
+    }
+    this.clearPendingPartialState();
   }
   setHistory(history) {
     this.history = history;
+    this.clearPendingPartialState();
   }
   truncateHistory(keepCount) {
     this.history = this.history.slice(0, keepCount);
+    this.clearPendingPartialState();
   }
   stripThoughtsFromHistory() {
     this.history = this.history.map(stripThoughtPartsFromContent).filter((content) => content !== null);
+    this.clearPendingPartialState();
   }
   /**
    * Pop all orphaned trailing user entries from chat history.
@@ -36429,6 +36646,14 @@ var GeminiChat = class {
     while (this.history.length > 0 && this.history[this.history.length - 1].role === "user") {
       this.history.pop();
     }
+    this.clearPendingPartialState();
+  }
+  /**
+   * Instance wrapper around the free-function {@link repairOrphanedToolUseTurns}.
+   * See the canonical note above `ORPHAN_TOOL_USE_REPAIR_REASON`.
+   */
+  repairOrphanedToolUseTurns(reason) {
+    return repairOrphanedToolUseTurns(this.history, reason);
   }
   setTools(tools) {
     this.generationConfig.tools = tools;
@@ -36465,31 +36690,38 @@ This error was probably caused by cyclic schema references in one of the followi
     let usageMetadata;
     let hasToolCall = false;
     let hasFinishReason = false;
-    for await (const chunk of streamResponse) {
-      hasFinishReason ||= chunk?.candidates?.some((candidate) => candidate.finishReason) ?? false;
-      if (isValidResponse(chunk)) {
-        const content = chunk.candidates?.[0]?.content;
-        if (content?.parts) {
-          if (content.parts.some((part) => part.functionCall)) {
-            hasToolCall = true;
-          }
-          allModelParts.push(...content.parts);
-        }
-      }
-      if (chunk.usageMetadata) {
-        usageMetadata = chunk.usageMetadata;
-        const lastPromptTokenCount = usageMetadata.promptTokenCount || usageMetadata.totalTokenCount;
-        if (lastPromptTokenCount) {
-          this.lastPromptTokenCount = lastPromptTokenCount;
-          this.telemetryService?.setLastPromptTokenCount(lastPromptTokenCount);
-        }
-        if (usageMetadata.cachedContentTokenCount && this.telemetryService) {
-          this.telemetryService.setLastCachedContentTokenCount(
-            usageMetadata.cachedContentTokenCount
-          );
+    let streamError = null;
+    try {
+      for await (const chunk of streamResponse) {
+        hasFinishReason ||= chunk?.candidates?.some((candidate) => candidate.finishReason) ?? false;
+        if (isValidResponse(chunk)) {
+          const content = chunk.candidates?.[0]?.content;
+          if (content?.parts) {
+            if (content.parts.some((part) => part.functionCall)) {
+              hasToolCall = true;
+            }
+            allModelParts.push(...content.parts);
+          }
+        }
+        if (chunk.usageMetadata) {
+          usageMetadata = chunk.usageMetadata;
+          const lastPromptTokenCount = usageMetadata.promptTokenCount || usageMetadata.totalTokenCount;
+          if (lastPromptTokenCount) {
+            this.lastPromptTokenCount = lastPromptTokenCount;
+            this.telemetryService?.setLastPromptTokenCount(
+              lastPromptTokenCount
+            );
+          }
+          if (usageMetadata.cachedContentTokenCount && this.telemetryService) {
+            this.telemetryService.setLastCachedContentTokenCount(
+              usageMetadata.cachedContentTokenCount
+            );
+          }
         }
+        yield chunk;
       }
-      yield chunk;
+    } catch (e) {
+      streamError = e;
     }
     let thoughtContentPart;
     const thoughtText = allModelParts.filter((part) => part.thought).map((part) => part.text).join("").trim();
@@ -36516,9 +36748,10 @@ This error was probably caused by cyclic schema references in one of the followi
       }
     }
     const contentText = consolidatedHistoryParts.filter((part) => part.text).map((part) => part.text).join("").trim();
-    if (thoughtContentPart || contentText || hasToolCall || usageMetadata) {
+    const willPersistToHistory = streamError === null || hasToolCall && (thoughtContentPart || consolidatedHistoryParts.length > 0);
+    if (willPersistToHistory && (thoughtContentPart || contentText || hasToolCall || usageMetadata)) {
       const contextWindowSize = this.config.getContentGeneratorConfig()?.contextWindowSize;
-      this.chatRecordingService?.recordAssistantTurn({
+      const recordArgs = {
         model,
         message: [
           ...thoughtContentPart ? [thoughtContentPart] : [],
@@ -36529,7 +36762,28 @@ This error was probably caused by cyclic schema references in one of the followi
         ],
         tokens: usageMetadata,
         contextWindowSize
-      });
+      };
+      if (streamError !== null) {
+        this.pendingPartialAssistantRecord = recordArgs;
+      } else {
+        this.chatRecordingService?.recordAssistantTurn(recordArgs);
+      }
+    }
+    if (streamError !== null) {
+      if (willPersistToHistory) {
+        this.history.push({
+          role: "model",
+          parts: [
+            ...thoughtContentPart ? [thoughtContentPart] : [],
+            ...consolidatedHistoryParts
+          ]
+        });
+        this.pendingPartialAssistantTurnIndex = this.history.length - 1;
+        debugLogger15.warn(
+          `[PARTIAL_PUSH] Persisting partial assistant turn for mid-stream error recovery (will be rolled back if retry succeeds, kept if break is unretryable). pendingIndex=${this.pendingPartialAssistantTurnIndex} callIds=${consolidatedHistoryParts.map((p) => p.functionCall?.id).filter((id) => Boolean(id)).join(",")} error=${streamError instanceof Error ? streamError.message : String(streamError)}`
+        );
+      }
+      throw streamError;
     }
     const hasAnyContent = contentText || thoughtText;
     if (!hasToolCall && (!hasFinishReason || !hasAnyContent)) {
@@ -67484,6 +67738,20 @@ var GeminiClient = class {
     }
     return void 0;
   }
+  /**
+   * Walk-only accessor for the set of `functionResponse.id` strings in
+   * raw history. Callers that only need the dedup id set (notably
+   * `useGeminiStream.handleCompletedTools`) MUST prefer this over
+   * {@link getHistory}, which deep-clones the entire conversation via
+   * `structuredClone` on every call. On long sessions with sizable
+   * tool outputs the clone is a multi-millisecond hit on the React UI
+   * thread; running it on every tool-completion batch caused visible
+   * frame drops during streaming. See
+   * `GeminiChat.getHistoryFunctionResponseIds` for the implementation.
+   */
+  getHistoryFunctionResponseIds() {
+    return this.getChat().getHistoryFunctionResponseIds();
+  }
   /**
    * Pop orphaned trailing user entries from the in-memory chat history.
    * Used by:
@@ -67511,6 +67779,46 @@ var GeminiClient = class {
     this.config.getFileReadCache().clear();
     this.forceFullIdeContext = true;
   }
+  /**
+   * Synthesize a `functionResponse` for every dangling `model[functionCall]`
+   * in chat history whose corresponding tool_result never landed. Inverse of
+   * {@link stripOrphanedUserEntriesFromHistory}, which only handles trailing
+   * `user` entries.
+   *
+   * This `GeminiClient` method is the resume-path entry point — called once
+   * from {@link startChat} after the transcript loads, covering `--resume`
+   * of a session that crashed between a partial-tool_use push and the
+   * tool's eventual completion.
+   *
+   * The other two coverage points (Retry submit path after
+   * `stripOrphanedUserEntriesFromHistory`, and the defensive pass at the
+   * start of every UserQuery / Cron send) live one layer down inside
+   * `GeminiChat.sendMessageStream` and call the standalone
+   * `repairOrphanedToolUseTurns(history)` function directly — they don't
+   * route through this wrapper. Anyone tracing the repair-pass coupling
+   * between the client and chat layers should follow that path
+   * separately rather than expect everything to funnel through here.
+   *
+   * Synthesizes an `error` `functionResponse`. The React tool scheduler
+   * (`useGeminiStream.handleCompletedTools`) MUST dedupe by `callId` against
+   * the live history before submitting its own `tool_result` — otherwise a
+   * late real result lands as a second `user[tool_result]` block (orphan
+   * because the synthetic already consumed the matching `tool_use`).
+   */
+  repairOrphanedToolUseTurnsInHistory(reason) {
+    const result = this.getChat().repairOrphanedToolUseTurns(reason);
+    if (result.injected.length > 0) {
+      debugLogger43.warn(
+        `[REPAIR] Synthesized ${result.injected.length} functionResponse(s) for dangling tool_use(s): ${result.injected.map((e) => `${e.name}(${e.callId})`).join(", ")}`
+      );
+    }
+    if (result.droppedDuplicates.length > 0) {
+      debugLogger43.warn(
+        `[REPAIR] Dropped ${result.droppedDuplicates.length} duplicate functionResponse(s) for callId(s): ${result.droppedDuplicates.map((e) => `${e.name}(${e.callId})`).join(", ")}`
+      );
+    }
+    return result;
+  }
   setHistory(history) {
     this.getChat().setHistory(history);
     debugLogger43.debug("[FILE_READ_CACHE] clear after setHistory");
@@ -67776,6 +68084,7 @@ var GeminiClient = class {
         this.config.getChatRecordingService(),
         uiTelemetryService
       );
+      this.repairOrphanedToolUseTurnsInHistory();
       const sessionStartAdditionalContext = await this.fireSessionStartHook(sessionStartSource);
       this.lastSessionStartContext = sessionStartAdditionalContext;
       this.lastSessionStartSource = sessionStartAdditionalContext ? sessionStartSource : void 0;
@@ -104180,7 +104489,7 @@ async function findProjectRoot2(startDir) {
       }
     } catch (error) {
       const isENOENT2 = typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
-      const isTestEnv = process.env["NODE_ENV"] === "test" || process.env["VITEST"];
+      const isTestEnv = process.env["VITEST"];
       if (!isENOENT2 && !isTestEnv) {
         if (typeof error === "object" && error !== null && "code" in error) {
           const fsError = error;
@@ -104343,7 +104652,7 @@ async function readGeminiMdFiles(filePaths, importFormat = "tree") {
           );
           return { filePath, content: processedResult.content };
         } catch (error) {
-          const isTestEnv = process.env["NODE_ENV"] === "test" || process.env["VITEST"];
+          const isTestEnv = process.env["VITEST"];
           if (!isTestEnv) {
             const message = error instanceof Error ? error.message : String(error);
             logger3.warn(
@@ -107055,19 +107364,19 @@ var Config = class {
     }, "registerStructuredOutputIfRequested");
     if (this.getBareMode()) {
       await registerLazy(ToolNames.READ_FILE, async () => {
-        const { ReadFileTool } = await import("./read-file-3JIOOXFT.js");
+        const { ReadFileTool } = await import("./read-file-G4TFJFZ2.js");
         return new ReadFileTool(this);
       });
       await registerLazy(ToolNames.EDIT, async () => {
-        const { EditTool } = await import("./edit-CBM5NDVK.js");
+        const { EditTool } = await import("./edit-JXJILHZW.js");
         return new EditTool(this);
       });
       await registerLazy(ToolNames.NOTEBOOK_EDIT, async () => {
-        const { NotebookEditTool } = await import("./notebook-edit-XUBTCT6L.js");
+        const { NotebookEditTool } = await import("./notebook-edit-7NXIUSLW.js");
         return new NotebookEditTool(this);
       });
       await registerLazy(ToolNames.SHELL, async () => {
-        const { ShellTool: ShellTool2 } = await import("./shell-3B5DZ437.js");
+        const { ShellTool: ShellTool2 } = await import("./shell-AXZQIDDU.js");
         return new ShellTool2(this);
       });
       await registerStructuredOutputIfRequested();
@@ -107077,11 +107386,11 @@ var Config = class {
       return registry;
     }
     await registerLazy(ToolNames.TOOL_SEARCH, async () => {
-      const { ToolSearchTool } = await import("./tool-search-ARWOD3GD.js");
+      const { ToolSearchTool } = await import("./tool-search-BTGLGBDQ.js");
       return new ToolSearchTool(this);
     });
     await registerLazy(ToolNames.AGENT, async () => {
-      const { AgentTool: AgentTool2 } = await import("./agent-K6OWOMBN.js");
+      const { AgentTool: AgentTool2 } = await import("./agent-QFQGDV7B.js");
       return new AgentTool2(this);
     });
     await registerLazy(ToolNames.TASK_STOP, async () => {
@@ -107093,7 +107402,7 @@ var Config = class {
       return new SendMessageTool(this);
     });
     await registerLazy(ToolNames.SKILL, async () => {
-      const { SkillTool } = await import("./skill-STSZUBXR.js");
+      const { SkillTool } = await import("./skill-IMUVSRRZ.js");
       return new SkillTool(this);
     });
     await registerLazy(ToolNames.LS, async () => {
@@ -107101,7 +107410,7 @@ var Config = class {
       return new LSTool(this);
     });
     await registerLazy(ToolNames.READ_FILE, async () => {
-      const { ReadFileTool } = await import("./read-file-3JIOOXFT.js");
+      const { ReadFileTool } = await import("./read-file-G4TFJFZ2.js");
       return new ReadFileTool(this);
     });
     if (this.getUseRipgrep()) {
@@ -107114,7 +107423,7 @@ var Config = class {
       }
       if (useRipgrep) {
         await registerLazy(ToolNames.GREP, async () => {
-          const { RipGrepTool: RipGrepTool2 } = await import("./ripGrep-LEI3L6PM.js");
+          const { RipGrepTool: RipGrepTool2 } = await import("./ripGrep-IMMYV3HQ.js");
           return new RipGrepTool2(this);
         });
       } else {
@@ -107127,34 +107436,34 @@ var Config = class {
           )
         );
         await registerLazy(ToolNames.GREP, async () => {
-          const { GrepTool } = await import("./grep-RV6V6T52.js");
+          const { GrepTool } = await import("./grep-RO7NJDWP.js");
           return new GrepTool(this);
         });
       }
     } else {
       await registerLazy(ToolNames.GREP, async () => {
-        const { GrepTool } = await import("./grep-RV6V6T52.js");
+        const { GrepTool } = await import("./grep-RO7NJDWP.js");
         return new GrepTool(this);
       });
     }
     await registerLazy(ToolNames.GLOB, async () => {
-      const { GlobTool } = await import("./glob-ZHA35VO5.js");
+      const { GlobTool } = await import("./glob-HZYBHMPB.js");
       return new GlobTool(this);
     });
     await registerLazy(ToolNames.EDIT, async () => {
-      const { EditTool } = await import("./edit-CBM5NDVK.js");
+      const { EditTool } = await import("./edit-JXJILHZW.js");
       return new EditTool(this);
     });
     await registerLazy(ToolNames.NOTEBOOK_EDIT, async () => {
-      const { NotebookEditTool } = await import("./notebook-edit-XUBTCT6L.js");
+      const { NotebookEditTool } = await import("./notebook-edit-7NXIUSLW.js");
       return new NotebookEditTool(this);
     });
     await registerLazy(ToolNames.WRITE_FILE, async () => {
-      const { WriteFileTool } = await import("./write-file-6MRT7TEW.js");
+      const { WriteFileTool } = await import("./write-file-BNUIFGU4.js");
       return new WriteFileTool(this);
     });
     await registerLazy(ToolNames.SHELL, async () => {
-      const { ShellTool: ShellTool2 } = await import("./shell-3B5DZ437.js");
+      const { ShellTool: ShellTool2 } = await import("./shell-AXZQIDDU.js");
       return new ShellTool2(this);
     });
     await registerLazy(ToolNames.TODO_WRITE, async () => {
@@ -107167,16 +107476,16 @@ var Config = class {
     });
     if (!this.sdkMode) {
       await registerLazy(ToolNames.EXIT_PLAN_MODE, async () => {
-        const { ExitPlanModeTool } = await import("./exitPlanMode-YDNPCSCJ.js");
+        const { ExitPlanModeTool } = await import("./exitPlanMode-WEETA2GM.js");
         return new ExitPlanModeTool(this);
       });
     }
     await registerLazy(ToolNames.ENTER_WORKTREE, async () => {
-      const { EnterWorktreeTool } = await import("./enter-worktree-XABKPLO6.js");
+      const { EnterWorktreeTool } = await import("./enter-worktree-HQ3RBRIA.js");
       return new EnterWorktreeTool(this);
     });
     await registerLazy(ToolNames.EXIT_WORKTREE, async () => {
-      const { ExitWorktreeTool } = await import("./exit-worktree-56MN2PCL.js");
+      const { ExitWorktreeTool } = await import("./exit-worktree-73TYZY5X.js");
       return new ExitWorktreeTool(this);
     });
     await registerLazy(ToolNames.WEB_FETCH, async () => {
@@ -107205,7 +107514,7 @@ var Config = class {
       });
     }
     await registerLazy(ToolNames.MONITOR, async () => {
-      const { MonitorTool } = await import("./monitor-5G2OBGE5.js");
+      const { MonitorTool } = await import("./monitor-IOU376UD.js");
       return new MonitorTool(this);
     });
     if (this.pendingMcpBudgetCallback) {
@@ -122690,6 +122999,7 @@ export {
   StreamEventType,
   isValidNonThoughtTextPart,
   InvalidStreamError,
+  repairOrphanedToolUseTurns,
   GeminiChat,
   isSchemaDepthError,
   isInvalidArgumentError,