nolo-cli 0.102.2 → 0.102.3

package/{chunk-ZQZZJIQI.js → chunk-BML3APFI.js}

@@ -2,7 +2,7 @@ import {
   DEVIN_CONNECT_URL,
   parseSseDataLineJson,
   parseSseDataLineObject
-} from "./chunk-OW4APERY.js";
+} from "./chunk-YK5MHOWM.js";
 import {
   applyChatCompletionDelta,
   applyResponsesToolEvent,
@@ -11,7 +11,7 @@ import {
   flushChatCompletionStream,
   providerHttpFailure,
   throwIfChatCompletionStreamFailed
-} from "./chunk-K4URP6NQ.js";
+} from "./chunk-VL3H5ZU3.js";
 import {
   readSseFrames
 } from "./chunk-GMZLP5DV.js";
@@ -33,7 +33,7 @@ import {
   hasParsableObjectArguments,
   repairTruncatedToolArguments,
   sanitizeForOutbound
-} from "./chunk-CQ3WA2NE.js";
+} from "./chunk-NKWIS6G2.js";
 import {
   createThinkParserState,
   createToolCallAccumulator,
@@ -14556,8 +14556,31 @@ function createResponsesStreamCollector(callbacks) {
   };
   const finalize2 = () => {
     let finalToolCalls = finalizeResponsesToolCalls(toolCallsAcc);
-    if (finalToolCalls.length === 0 && completedResponse) {
-      finalToolCalls = extractToolCallsFromResponseOutput(completedResponse);
+    if (completedResponse) {
+      const completedToolCalls = extractToolCallsFromResponseOutput(completedResponse);
+      const completedById = new Map(completedToolCalls.map((call) => [call.id, call]));
+      finalToolCalls = finalToolCalls.map((call) => {
+        const completed = completedById.get(call.id);
+        if (!completed) return call;
+        let accumulatedParses = false;
+        let completedParses = false;
+        try {
+          JSON.parse(call.function.arguments);
+          accumulatedParses = true;
+        } catch {
+        }
+        try {
+          JSON.parse(completed.function.arguments);
+          completedParses = true;
+        } catch {
+          return call;
+        }
+        if (completedParses && (!accumulatedParses || completed.function.arguments.startsWith(call.function.arguments))) {
+          return { ...call, function: { ...call.function, arguments: completed.function.arguments } };
+        }
+        return call;
+      });
+      if (finalToolCalls.length === 0) finalToolCalls = completedToolCalls;
     }
     if (!content && completedResponse) {
       content = extractTextFromResponseOutput(completedResponse);

package/{chunk-Z5X5MD6D.js → chunk-CMKQ7RCH.js}

@@ -1,6 +1,6 @@
 import {
   clearCliLocalRuntimePreparedAgentCache
-} from "./chunk-V3R3UZ4F.js";
+} from "./chunk-MEZSLGQZ.js";
 import {
   getReadableCliDb
 } from "./chunk-LOCNXNOU.js";

package/{chunk-NMMU6M4Z.js → chunk-GLD6Q25H.js}

@@ -14,7 +14,7 @@ import {
 } from "./chunk-AGGIDPCZ.js";
 import {
   runLlm
-} from "./chunk-TAPMD4SO.js";
+} from "./chunk-JVP74JRH.js";
 import {
   cleanupCliSessionForDialog
 } from "./chunk-2K4TM6AW.js";
@@ -10528,7 +10528,7 @@ var messageSlice = createSliceWithThunks({
             runtimeOptions: args.runtimeOptions
           });
           if (agentKeyToUse) {
-            const { streamAgentChatTurn } = await import("./agentSlice-4JIT2XG4.js");
+            const { streamAgentChatTurn } = await import("./agentSlice-MR6JWMM5.js");
             await dispatch(
               streamAgentChatTurn({
                 agentKey: agentKeyToUse,
@@ -13273,7 +13273,7 @@ var deleteDialogThunk = async (payload, thunkApi) => {
   }
   if (isCurrentDialog) {
     await thunkApi.dispatch(resetMsgs());
-    const { clearPendingAttachments: clearPendingAttachments2 } = await import("./dialogSlice-LUUVLJKZ.js");
+    const { clearPendingAttachments: clearPendingAttachments2 } = await import("./dialogSlice-KXBFWRVK.js");
     dispatch(clearPendingAttachments2());
   }
   return { dialogKey, isCurrentDialog, attachmentPlan };
@@ -13281,15 +13281,15 @@ var deleteDialogThunk = async (payload, thunkApi) => {
 
 // packages/chat/dialog/dialogSlice.ts
 var runCreateDialogAction = async (args, thunkApi) => {
-  const { createDialogAction } = await import("./createDialogAction-BYCJKWFY.js");
+  const { createDialogAction } = await import("./createDialogAction-VODZCSHM.js");
   return createDialogAction(args, thunkApi);
 };
 var runCreateAgentAutomationAction = async (args, thunkApi) => {
-  const { createAgentAutomationAction } = await import("./createAgentAutomationAction-4MV3MWVE.js");
+  const { createAgentAutomationAction } = await import("./createAgentAutomationAction-C5UTM2ZI.js");
   return createAgentAutomationAction(args, thunkApi);
 };
 var runUpdateDialogTitleAction = async (args, thunkApi) => {
-  const { updateDialogTitleAction } = await import("./updateDialogTitleAction-DBW4OTMM.js");
+  const { updateDialogTitleAction } = await import("./updateDialogTitleAction-NKHQ5LCX.js");
   return updateDialogTitleAction(args, thunkApi);
 };
 var runAddDialogAgentAction = async (args, thunkApi) => {
@@ -13313,7 +13313,7 @@ var runSetDialogExtraReferencesAction = async (args, thunkApi) => {
   return setDialogExtraReferencesAction(args, thunkApi);
 };
 var runHandleSendMessageAction = async (args, thunkApi) => {
-  const { handleSendMessageAction } = await import("./handleSendMessageAction-CW5HSH4E.js");
+  const { handleSendMessageAction } = await import("./handleSendMessageAction-BBB6A54Z.js");
   return handleSendMessageAction(args, thunkApi);
 };
 function clearDialogState() {
@@ -13326,7 +13326,7 @@ var createPageAndAddReference = createAsyncThunk(
   async (payload, { dispatch, getState, rejectWithValue }) => {
     const { slateData, jsonData, title, type, fileId, groupId, dialogKey } = payload;
     try {
-      const { createDocState } = await import("./docStore-RRAGFCNQ.js");
+      const { createDocState } = await import("./docStore-PLGBTV5U.js");
       const pageKey = await createDocState(
         { slateData, title },
         { dispatch, getState }

package/{chunk-NGO72MN2.js → chunk-HDYUKPEB.js}

@@ -1,13 +1,13 @@
 import {
   createCliLocalRuntimeAdapter,
   summarizeEndpoint
-} from "./chunk-V3R3UZ4F.js";
+} from "./chunk-MEZSLGQZ.js";
 import {
   clipMultilineText
-} from "./chunk-TTMNMJVI.js";
+} from "./chunk-YIEUDVD6.js";
 import {
   runLocalAgentTurn
-} from "./chunk-ZQZZJIQI.js";
+} from "./chunk-BML3APFI.js";
 import {
   applyToolSurfaceConstraints
 } from "./chunk-7KWFIKKK.js";

package/{chunk-TAPMD4SO.js → chunk-JVP74JRH.js}

@@ -306,7 +306,7 @@ var slice = createSliceWithThunks({
       const overrides = {};
       if (args.systemPromptOverride !== void 0) overrides.prompt = args.systemPromptOverride;
       if (args.toolsOverride !== void 0) overrides.tools = args.toolsOverride;
-      const { _executeModel } = await import("./_executeModel-B6SS2ISV.js");
+      const { _executeModel } = await import("./_executeModel-TOH473HN.js");
       return _executeModel(
         {
           isStreaming: args.isStreaming ?? false,
@@ -327,7 +327,7 @@ var slice = createSliceWithThunks({
      * - 循环直到无工具调用或触发其他运行时停止条件
      */
     runAgent: create.asyncThunk(async (args, thunkApi) => {
-      const { runAgentClientLoop } = await import("./runAgentClientLoop-4XIIPXH3.js");
+      const { runAgentClientLoop } = await import("./runAgentClientLoop-CAPNBF7Q.js");
       const { content: loopContent, toolCallCount } = await runAgentClientLoop(
         {
           agentKey: args.agentKey,
@@ -343,7 +343,7 @@ var slice = createSliceWithThunks({
      * 聊天轮次流式 Agent 调用
      */
     streamAgentChatTurn: create.asyncThunk(async (args, thunkApi) => {
-      const { streamAgentChatTurnHandler } = await import("./streamAgentChatTurn-WRLQAWTW.js");
+      const { streamAgentChatTurnHandler } = await import("./streamAgentChatTurn-XX3N3P4J.js");
       return streamAgentChatTurnHandler(args, thunkApi);
     }),
     /**

package/{chunk-V3R3UZ4F.js → chunk-MEZSLGQZ.js}

@@ -45,7 +45,7 @@ import {
 import {
   inlineImageUrlsForCustomProvider,
   prepareTools
-} from "./chunk-2K54PIZY.js";
+} from "./chunk-6XHM3LNF.js";
 import {
   getServerProviderSecret
 } from "./chunk-HS7MLR74.js";
@@ -63,7 +63,7 @@ import {
   rememberMemoryFunctionSchema,
   resolveAgentRequiredPackIds,
   setTodoListFunc
-} from "./chunk-TTMNMJVI.js";
+} from "./chunk-YIEUDVD6.js";
 import {
   deriveCredentialGroup,
   deriveCustomProviderCredentialGroup
@@ -115,14 +115,14 @@ import {
   prepareTokenUsageData,
   resolveBuiltinPlatformAgentConfig,
   runKeyed
-} from "./chunk-NMMU6M4Z.js";
+} from "./chunk-GLD6Q25H.js";
 import {
   BUILTIN_DIALOG_LLM_CHAT_FALLBACK_MODEL,
   BUILTIN_TITLE_LLM_CONFIG
 } from "./chunk-523DITKR.js";
 import {
   fetchServerSyncedCredential
-} from "./chunk-TAPMD4SO.js";
+} from "./chunk-JVP74JRH.js";
 import {
   FORCED_TOOLS,
   addDefaultLightWebToolsForConfiguredAgents,
@@ -163,7 +163,7 @@ import {
   readDevinUpstreamFailure,
   resolveOpenAiCompatibleProviderConfig,
   resolveSessionKey
-} from "./chunk-ZQZZJIQI.js";
+} from "./chunk-BML3APFI.js";
 import {
   accumulateGeminiChunks,
   buildGeminiGenerateContentRequest,
@@ -174,7 +174,7 @@ import {
   parseUpstreamErrorBody,
   resolveAntigravityFinishReason,
   shouldUseGeminiNativeToolRoute
-} from "./chunk-OW4APERY.js";
+} from "./chunk-YK5MHOWM.js";
 import {
   PlatformStreamInterruptedError,
   buildPlatformChatCompletionRequest,
@@ -185,7 +185,7 @@ import {
   readPlatformChatSseCompletion,
   resolvePlatformChatProviderConfig,
   shouldUsePlatformChatProvider
-} from "./chunk-K4URP6NQ.js";
+} from "./chunk-VL3H5ZU3.js";
 import {
   readSseDataValues
 } from "./chunk-GMZLP5DV.js";

package/chunk-NKWIS6G2.js

@@ -0,0 +1,442 @@
+// packages/agent-runtime/declaredToolNames.ts
+function extractDeclaredToolNames(tools) {
+  if (!Array.isArray(tools)) return void 0;
+  const names = /* @__PURE__ */ new Set();
+  for (const t of tools) {
+    const fn = t?.function;
+    if (fn && typeof fn.name === "string" && fn.name) names.add(fn.name);
+  }
+  return names;
+}
+
+// packages/agent-runtime/outboundHistorySanitize.ts
+function sanitizeForOutbound(messages, tools) {
+  return sanitizeOutboundHistory(messages, {
+    declaredToolNames: extractDeclaredToolNames(tools)
+  });
+}
+function stableToolCallId(assistantIndex, callIndex) {
+  return `call_sanitize_${assistantIndex}_${callIndex}`;
+}
+function isString(v) {
+  return typeof v === "string";
+}
+function isNonEmptyString(v) {
+  return typeof v === "string" && v.length > 0;
+}
+function joinLines(...parts) {
+  return parts.filter(isNonEmptyString).join("\n");
+}
+function jsonStringifyArguments(args) {
+  if (typeof args === "string") return args;
+  try {
+    return JSON.stringify(args ?? "");
+  } catch {
+    return "";
+  }
+}
+function renderToolCallAsText(call) {
+  const c = call && typeof call === "object" ? call : {};
+  const name = isString(c.function?.name) && c.function.name.length > 0 ? c.function.name : "unknown";
+  const rawArgs = c.function?.arguments;
+  const args = jsonStringifyArguments(rawArgs);
+  return `[tool_call: ${name}(${args})]`;
+}
+function renderToolResultAsText(message) {
+  const name = isNonEmptyString(message.toolName) ? message.toolName : "tool";
+  const body = typeof message.content === "string" ? message.content : "";
+  return `[tool_result: ${name}: ${body}]`;
+}
+function normalizeToolCall(call, assistantIndex, callIndex) {
+  if (!call || typeof call !== "object") return null;
+  const c = call;
+  const fn = c.function;
+  if (!fn || typeof fn !== "object" || !isString(fn.name) || fn.name.length === 0) return null;
+  const id = isNonEmptyString(c.id) ? c.id : stableToolCallId(assistantIndex, callIndex);
+  return {
+    id,
+    type: isString(c.type) && c.type ? c.type : "function",
+    function: { name: fn.name, arguments: jsonStringifyArguments(fn.arguments) },
+    ...typeof c.thought_signature === "string" ? { thought_signature: c.thought_signature } : {}
+  };
+}
+function classifyAssistantCalls(toolCalls, assistantIndex) {
+  const callIds = [];
+  const idCounts = /* @__PURE__ */ new Map();
+  const unparsableIndices = /* @__PURE__ */ new Set();
+  const unparsableIds = /* @__PURE__ */ new Set();
+  toolCalls.forEach((rawCall, callIndex) => {
+    const c = rawCall && typeof rawCall === "object" ? rawCall : {};
+    const id = isNonEmptyString(c.id) ? c.id : stableToolCallId(assistantIndex, callIndex);
+    callIds.push(id);
+    idCounts.set(id, (idCounts.get(id) ?? 0) + 1);
+    if (!hasParsableObjectArguments(c.function?.arguments)) {
+      unparsableIndices.add(callIndex);
+      unparsableIds.add(id);
+    }
+  });
+  const duplicateIds = /* @__PURE__ */ new Set();
+  for (const [id, count] of idCounts) {
+    if (count > 1) duplicateIds.add(id);
+  }
+  return { callIds, duplicateIds, unparsableIndices, unparsableIds };
+}
+function sanitizeOutboundHistory(messages, options) {
+  if (!Array.isArray(messages) || messages.length === 0) return messages;
+  const declared = options?.declaredToolNames;
+  const keptCallIndicesPerAssistant = /* @__PURE__ */ new Map();
+  const keptToolIndices = /* @__PURE__ */ new Set();
+  let i = 0;
+  while (i < messages.length) {
+    const m = messages[i];
+    if (m.role === "assistant" && Array.isArray(m.tool_calls) && m.tool_calls.length > 0) {
+      const asstIdx = i;
+      const { callIds, duplicateIds, unparsableIndices } = classifyAssistantCalls(m.tool_calls, asstIdx);
+      const candidateCallMap = /* @__PURE__ */ new Map();
+      m.tool_calls.forEach((call, callIndex) => {
+        const id = callIds[callIndex];
+        if (duplicateIds.has(id)) return;
+        if (unparsableIndices.has(callIndex)) return;
+        const name = call?.function?.name;
+        if (!isString(name) || name.length === 0) return;
+        const declaredAllows = !declared || declared.has(name);
+        if (!declaredAllows) return;
+        candidateCallMap.set(id, callIndex);
+      });
+      let j = i + 1;
+      const matchedCallIndices = /* @__PURE__ */ new Set();
+      const matchedToolIds = /* @__PURE__ */ new Set();
+      while (j < messages.length && messages[j].role === "tool") {
+        const toolMsg = messages[j];
+        const toolCallId = isNonEmptyString(toolMsg.tool_call_id) ? toolMsg.tool_call_id : "";
+        if (toolCallId && candidateCallMap.has(toolCallId) && !matchedToolIds.has(toolCallId)) {
+          matchedToolIds.add(toolCallId);
+          matchedCallIndices.add(candidateCallMap.get(toolCallId));
+          keptToolIndices.add(j);
+        }
+        j++;
+      }
+      keptCallIndicesPerAssistant.set(asstIdx, matchedCallIndices);
+      i = j;
+    } else {
+      i++;
+    }
+  }
+  const out = [];
+  let k = 0;
+  while (k < messages.length) {
+    const m = messages[k];
+    if (m.role === "assistant" && Array.isArray(m.tool_calls) && m.tool_calls.length > 0) {
+      const asstIdx = k;
+      const keptIndices = keptCallIndicesPerAssistant.get(asstIdx) ?? /* @__PURE__ */ new Set();
+      const keptToolCalls = [];
+      const downgradedCallLines = [];
+      m.tool_calls.forEach((call, callIndex) => {
+        const name = call?.function?.name;
+        const declaredAllows = !declared || isString(name) && declared.has(name);
+        const keep = keptIndices.has(callIndex) && declaredAllows && hasParsableObjectArguments(call?.function?.arguments);
+        if (keep) {
+          const normalized = normalizeToolCall(call, asstIdx, callIndex);
+          if (normalized) {
+            keptToolCalls.push(normalized);
+          } else {
+            downgradedCallLines.push(renderToolCallAsText(call));
+          }
+        } else {
+          downgradedCallLines.push(renderToolCallAsText(call));
+        }
+      });
+      if (keptToolCalls.length === 0) {
+        const downgradedText = joinLines(...downgradedCallLines);
+        const contentWithDowngrade = downgradedText.length > 0 ? combineContentWithText(m.content, downgradedText) : m.content;
+        const sanitizedAssistant2 = {
+          ...m,
+          content: contentWithDowngrade
+        };
+        delete sanitizedAssistant2.tool_calls;
+        out.push(sanitizedAssistant2);
+        let nextIdx2 = k + 1;
+        while (nextIdx2 < messages.length && messages[nextIdx2].role === "tool") {
+          out.push({
+            role: "assistant",
+            content: renderToolResultAsText(messages[nextIdx2])
+          });
+          nextIdx2++;
+        }
+        k = nextIdx2;
+        continue;
+      }
+      const sanitizedAssistant = {
+        ...m,
+        tool_calls: keptToolCalls
+      };
+      out.push(sanitizedAssistant);
+      let nextIdx = k + 1;
+      const deferredResultLines = [];
+      while (nextIdx < messages.length && messages[nextIdx].role === "tool") {
+        if (keptToolIndices.has(nextIdx)) {
+          const toolMsg = messages[nextIdx];
+          out.push({
+            ...toolMsg,
+            content: toolMsg.content ?? "",
+            tool_call_id: toolMsg.tool_call_id
+          });
+        } else {
+          deferredResultLines.push(renderToolResultAsText(messages[nextIdx]));
+        }
+        nextIdx++;
+      }
+      const deferredLines = [...downgradedCallLines, ...deferredResultLines];
+      if (deferredLines.length > 0) {
+        out.push({
+          role: "assistant",
+          content: joinLines(...deferredLines)
+        });
+      }
+      k = nextIdx;
+      continue;
+    }
+    if (m.role === "tool") {
+      out.push({
+        role: "assistant",
+        content: renderToolResultAsText(m)
+      });
+      k++;
+      continue;
+    }
+    out.push({ ...m });
+    k++;
+  }
+  return out;
+}
+function combineContentWithText(base, extra) {
+  if (typeof base === "string") {
+    return base ? `${base}
+${extra}` : extra;
+  }
+  if (Array.isArray(base)) {
+    return [...base, { type: "text", text: extra }];
+  }
+  return extra;
+}
+function hasParsableObjectArguments(raw) {
+  if (raw === void 0) return true;
+  if (raw === null || typeof raw === "number" || typeof raw === "boolean") {
+    return false;
+  }
+  if (typeof raw !== "string") return true;
+  if (raw.trim() === "") return true;
+  try {
+    const parsed = JSON.parse(raw);
+    return parsed !== null && typeof parsed === "object";
+  } catch {
+    return false;
+  }
+}
+var STRICT_JSON_STRING_TOKEN = /^"(?:[^"\\\u0000-\u001F]|\\["\\/bfnrt]|\\u[0-9A-Fa-f]{4})*"$/;
+function isStrictJsonStringToken(value) {
+  if (!STRICT_JSON_STRING_TOKEN.test(value)) return false;
+  try {
+    return typeof JSON.parse(value) === "string";
+  } catch {
+    return false;
+  }
+}
+function closersOf(openStack) {
+  return openStack.slice().reverse().map((ch) => ch === "{" ? "}" : "]").join("");
+}
+function scanJsonForTailRepair(input) {
+  const stack = [];
+  let inString = false;
+  let escaped = false;
+  let lastCommaOutsideString = null;
+  for (let i = 0; i < input.length; i += 1) {
+    const ch = input[i];
+    if (inString) {
+      if (escaped) escaped = false;
+      else if (ch === "\\") escaped = true;
+      else if (ch === '"') inString = false;
+      continue;
+    }
+    if (ch === '"') {
+      inString = true;
+      continue;
+    }
+    if (ch === "{" || ch === "[") {
+      stack.push(ch);
+      continue;
+    }
+    if (ch === "}" || ch === "]") {
+      const open = stack.pop();
+      if (open !== (ch === "}" ? "{" : "[")) return null;
+      continue;
+    }
+    if (ch === ",") {
+      lastCommaOutsideString = { index: i, closers: closersOf(stack) };
+      continue;
+    }
+  }
+  return { inString, closers: closersOf(stack), lastCommaOutsideString };
+}
+function repairTruncatedToolArguments(raw) {
+  if (typeof raw !== "string") return null;
+  const withoutTrailingSpace = raw.replace(/\s+$/, "");
+  const endsWithComma = withoutTrailingSpace.endsWith(",");
+  const trimmed = endsWithComma ? withoutTrailingSpace.slice(0, -1).replace(/\s+$/, "") : withoutTrailingSpace;
+  if (trimmed === "" || trimmed.endsWith(",")) return null;
+  const scan = scanJsonForTailRepair(trimmed);
+  if (!scan || scan.inString) return null;
+  const lastChar = trimmed[trimmed.length - 1];
+  const tailIsCompleteToken = endsWithComma || lastChar === '"' || lastChar === "}" || lastChar === "]";
+  if (!tailIsCompleteToken) return null;
+  const candidates = [trimmed + scan.closers];
+  const lastComma = scan.lastCommaOutsideString;
+  if (lastComma && lastComma.index > 0) {
+    const tailAfterComma = trimmed.slice(lastComma.index + 1).trim();
+    if (isStrictJsonStringToken(tailAfterComma)) {
+      const head = trimmed.slice(0, lastComma.index);
+      candidates.push(head + lastComma.closers);
+    }
+  }
+  for (const candidate of candidates) {
+    try {
+      const parsed = JSON.parse(candidate);
+      if (parsed !== null && typeof parsed === "object" && !Array.isArray(parsed) && Object.keys(parsed).length > 0) {
+        return candidate;
+      }
+    } catch {
+    }
+  }
+  return null;
+}
+function downgradeUnparsableToolCalls(messages) {
+  if (!Array.isArray(messages) || messages.length === 0) {
+    return { messages, downgraded: 0 };
+  }
+  let hasAnyPoison = false;
+  for (const m of messages) {
+    if (m.role === "assistant" && Array.isArray(m.tool_calls)) {
+      for (const call of m.tool_calls) {
+        if (!hasParsableObjectArguments(call?.function?.arguments)) {
+          hasAnyPoison = true;
+          break;
+        }
+      }
+    }
+    if (hasAnyPoison) break;
+  }
+  if (!hasAnyPoison) return { messages, downgraded: 0 };
+  const poisonedCallsPerAssistant = /* @__PURE__ */ new Map();
+  const poisonedToolIndices = /* @__PURE__ */ new Set();
+  let i = 0;
+  while (i < messages.length) {
+    const m = messages[i];
+    if (m.role === "assistant" && Array.isArray(m.tool_calls) && m.tool_calls.length > 0) {
+      const asstIdx = i;
+      const { unparsableIds } = classifyAssistantCalls(m.tool_calls, asstIdx);
+      let j = i + 1;
+      while (j < messages.length && messages[j].role === "tool") {
+        const toolMsg = messages[j];
+        const toolCallId = isNonEmptyString(toolMsg.tool_call_id) ? toolMsg.tool_call_id : "";
+        if (toolCallId && unparsableIds.has(toolCallId)) {
+          poisonedToolIndices.add(j);
+        }
+        j++;
+      }
+      if (unparsableIds.size > 0) {
+        poisonedCallsPerAssistant.set(asstIdx, unparsableIds);
+      }
+      i = j;
+    } else {
+      i++;
+    }
+  }
+  let downgraded = 0;
+  const out = [];
+  let k = 0;
+  while (k < messages.length) {
+    const m = messages[k];
+    if (m.role === "assistant" && Array.isArray(m.tool_calls) && m.tool_calls.length > 0) {
+      const badIds = poisonedCallsPerAssistant.get(k);
+      if (!badIds || badIds.size === 0) {
+        out.push(m);
+        k++;
+        continue;
+      }
+      const kept = [];
+      const lines = [];
+      const { callIds } = classifyAssistantCalls(m.tool_calls, k);
+      m.tool_calls.forEach((call, callIndex) => {
+        const id = callIds[callIndex];
+        if (badIds.has(id)) {
+          lines.push(renderToolCallAsText(call));
+          downgraded++;
+        } else {
+          kept.push(call);
+        }
+      });
+      if (kept.length === 0) {
+        const sanitized2 = {
+          ...m,
+          content: combineContentWithText(m.content, joinLines(...lines))
+        };
+        delete sanitized2.tool_calls;
+        out.push(sanitized2);
+        let nextIdx2 = k + 1;
+        while (nextIdx2 < messages.length && messages[nextIdx2].role === "tool") {
+          if (poisonedToolIndices.has(nextIdx2)) {
+            out.push({ role: "assistant", content: renderToolResultAsText(messages[nextIdx2]) });
+          } else {
+            out.push(messages[nextIdx2]);
+          }
+          nextIdx2++;
+        }
+        k = nextIdx2;
+        continue;
+      }
+      const sanitized = {
+        ...m,
+        content: lines.length > 0 ? combineContentWithText(m.content, joinLines(...lines)) : m.content,
+        tool_calls: kept
+      };
+      out.push(sanitized);
+      let nextIdx = k + 1;
+      const deferredResultLines = [];
+      while (nextIdx < messages.length && messages[nextIdx].role === "tool") {
+        if (poisonedToolIndices.has(nextIdx)) {
+          deferredResultLines.push(renderToolResultAsText(messages[nextIdx]));
+        } else {
+          out.push(messages[nextIdx]);
+        }
+        nextIdx++;
+      }
+      if (deferredResultLines.length > 0) {
+        out.push({
+          role: "assistant",
+          content: joinLines(...deferredResultLines)
+        });
+      }
+      k = nextIdx;
+      continue;
+    }
+    if (m.role === "tool") {
+      if (poisonedToolIndices.has(k)) {
+        out.push({ role: "assistant", content: renderToolResultAsText(m) });
+      } else {
+        out.push(m);
+      }
+      k++;
+      continue;
+    }
+    out.push(m);
+    k++;
+  }
+  return { messages: out, downgraded };
+}
+
+export {
+  sanitizeForOutbound,
+  hasParsableObjectArguments,
+  repairTruncatedToolArguments,
+  downgradeUnparsableToolCalls
+};

package/{chunk-5UQRASYE.js → chunk-NR7N2RWA.js}

@@ -1,12 +1,12 @@
 import {
   addContentToSpace
-} from "./chunk-GJ647AYV.js";
+} from "./chunk-REPRKRB2.js";
 import {
   format,
   prepareAndPersistMessage,
   uiAskChoiceFunc,
   uiAskChoiceFunctionSchema
-} from "./chunk-NMMU6M4Z.js";
+} from "./chunk-GLD6Q25H.js";
 import {
   formatISO
 } from "./chunk-ZRAU6T47.js";