sparkecoder 0.1.73 → 0.1.74

package/dist/cli.js

@@ -2962,9 +2962,8 @@ function createRemoteModel(modelId, config) {
       });
       if (!res.ok) {
         const err = await res.json().catch(() => ({}));
-        throw new Error(
-          `Remote inference failed (${res.status}): ${err.error || res.statusText}`
-        );
+        const detail = formatRemoteError(res.status, modelId, err);
+        throw new Error(detail);
       }
       const result = await res.json();
       return deserializeValue(result);
@@ -2981,9 +2980,8 @@ function createRemoteModel(modelId, config) {
       });
       if (!res.ok) {
         const err = await res.json().catch(() => ({}));
-        throw new Error(
-          `Remote inference failed (${res.status}): ${err.error || res.statusText}`
-        );
+        const detail = formatRemoteError(res.status, modelId, err);
+        throw new Error(detail);
       }
       const reader = res.body.getReader();
       const decoder = new TextDecoder();
@@ -3041,6 +3039,18 @@ function createRemoteModel(modelId, config) {
     }
   };
 }
+function formatRemoteError(status, modelId, body) {
+  const parts = [`Remote inference failed (${status}) for ${modelId}`];
+  if (body.error) parts.push(body.error);
+  if (body.details) {
+    const d = body.details;
+    if (d.type) parts.push(`type=${d.type}`);
+    if (d.statusCode && d.statusCode !== status) parts.push(`upstream=${d.statusCode}`);
+    if (d.cause) parts.push(`cause: ${d.cause}`);
+    if (d.orderWarnings?.length) parts.push(`prompt issues: ${d.orderWarnings.join("; ")}`);
+  }
+  return parts.join(" \u2014 ");
+}
 
 // src/agent/model.ts
 init_config();
@@ -7279,6 +7289,7 @@ ${summaryContent}`
         ...messages
       ];
     }
+    messages = repairToolPairing(messages);
     return messages;
   }
   // ---------------------------------------------------------------------------
@@ -7287,25 +7298,43 @@ ${summaryContent}`
   /**
    * Strip non-essential content from messages older than the most recent
    * `recentCount`. Operates in-memory only — does not touch the DB.
+   *
+   * Tracks removed tool-call IDs so matching tool-results are also removed,
+   * preventing orphaned tool_result blocks that providers reject.
    */
   compactOlderMessages(messages, recentCount) {
     if (messages.length <= recentCount) return messages;
     const boundary = messages.length - recentCount;
     const olderMessages = messages.slice(0, boundary);
     const recentMessages = messages.slice(boundary);
+    const removedToolCallIds = /* @__PURE__ */ new Set();
     const compacted = [];
     for (const msg of olderMessages) {
-      const processed = this.compactMessage(msg);
+      const processed = this.compactMessage(msg, removedToolCallIds);
       if (processed) compacted.push(processed);
     }
+    if (removedToolCallIds.size > 0) {
+      const cleaned = [];
+      for (const msg of compacted) {
+        const result = stripOrphanedToolResults(msg, removedToolCallIds);
+        if (result) cleaned.push(result);
+      }
+      return [...cleaned, ...recentMessages];
+    }
     return [...compacted, ...recentMessages];
   }
-  compactMessage(msg) {
+  compactMessage(msg, removedToolCallIds) {
     if (!Array.isArray(msg.content)) return msg;
     const parts = [];
     for (const part of msg.content) {
-      if (part.type === "tool-call" && part.toolName === "todo") continue;
-      if (part.type === "tool-result" && part.toolName === "todo") continue;
+      if (part.type === "tool-call" && part.toolName === "todo") {
+        if (part.toolCallId) removedToolCallIds.add(part.toolCallId);
+        continue;
+      }
+      if (part.type === "tool-result" && part.toolName === "todo") {
+        if (part.toolCallId) removedToolCallIds.add(part.toolCallId);
+        continue;
+      }
       if (part.type === "reasoning" || part.type === "thinking") continue;
       if (part.type === "tool-result" && COMPACTABLE_TOOLS.has(part.toolName)) {
         parts.push(this.trimToolResult(part));
@@ -7455,6 +7484,51 @@ ${summaryContent}`
     this.summaries = [];
   }
 };
+function stripOrphanedToolResults(msg, removedIds) {
+  if (!Array.isArray(msg.content)) return msg;
+  const parts = msg.content.filter((part) => {
+    if (part.type === "tool-result" && removedIds.has(part.toolCallId)) return false;
+    if (part.type === "tool-call" && removedIds.has(part.toolCallId)) return false;
+    return true;
+  });
+  if (parts.length === 0) return null;
+  return { ...msg, content: parts };
+}
+function repairToolPairing(messages) {
+  const toolCallIds = /* @__PURE__ */ new Set();
+  const toolResultIds = /* @__PURE__ */ new Set();
+  for (const msg of messages) {
+    if (!Array.isArray(msg.content)) continue;
+    for (const part of msg.content) {
+      if (part.type === "tool-call" && part.toolCallId) toolCallIds.add(part.toolCallId);
+      if (part.type === "tool-result" && part.toolCallId) toolResultIds.add(part.toolCallId);
+    }
+  }
+  const orphanedCalls = new Set([...toolCallIds].filter((id) => !toolResultIds.has(id)));
+  const orphanedResults = new Set([...toolResultIds].filter((id) => !toolCallIds.has(id)));
+  if (orphanedCalls.size === 0 && orphanedResults.size === 0) return messages;
+  if (orphanedCalls.size > 0) {
+    console.warn(`[tool-repair] Removing ${orphanedCalls.size} orphaned tool-call(s) with no matching result`);
+  }
+  if (orphanedResults.size > 0) {
+    console.warn(`[tool-repair] Removing ${orphanedResults.size} orphaned tool-result(s) with no matching call`);
+  }
+  const repaired = [];
+  for (const msg of messages) {
+    if (!Array.isArray(msg.content)) {
+      repaired.push(msg);
+      continue;
+    }
+    const parts = msg.content.filter((part) => {
+      if (part.type === "tool-call" && orphanedCalls.has(part.toolCallId)) return false;
+      if (part.type === "tool-result" && orphanedResults.has(part.toolCallId)) return false;
+      return true;
+    });
+    if (parts.length === 0) continue;
+    repaired.push({ ...msg, content: parts });
+  }
+  return repaired;
+}
 
 // src/agent/index.ts
 init_webhook();