sparkecoder 0.1.122 → 0.1.123

package/dist/cli.js

@@ -8202,6 +8202,55 @@ function wrapToolsNeverThrow(tools) {
   }
   return wrapped;
 }
+function ensureToolResultsFollowCalls(messages) {
+  if (!Array.isArray(messages) || messages.length < 3) return messages;
+  let mutated = false;
+  const result = messages.slice();
+  let i = 0;
+  while (i < result.length) {
+    const msg = result[i];
+    if (msg?.role !== "assistant" || !Array.isArray(msg.content)) {
+      i++;
+      continue;
+    }
+    const callIds = /* @__PURE__ */ new Set();
+    for (const part of msg.content) {
+      if (part?.type === "tool-call" && typeof part.toolCallId === "string") {
+        callIds.add(part.toolCallId);
+      }
+    }
+    if (callIds.size === 0) {
+      i++;
+      continue;
+    }
+    let toolIdx = -1;
+    for (let j = i + 1; j < result.length; j++) {
+      const m = result[j];
+      if (m?.role === "assistant" && Array.isArray(m.content) && m.content.some((p) => p?.type === "tool-call")) {
+        break;
+      }
+      if (m?.role === "tool" && Array.isArray(m.content)) {
+        const answersOne = m.content.some(
+          (p) => p?.type === "tool-result" && typeof p.toolCallId === "string" && callIds.has(p.toolCallId)
+        );
+        if (answersOne) {
+          toolIdx = j;
+          break;
+        }
+      }
+    }
+    if (toolIdx > i + 1) {
+      const [toolMsg] = result.splice(toolIdx, 1);
+      result.splice(i + 1, 0, toolMsg);
+      mutated = true;
+      console.warn(
+        `[tool-repair] Reordered tool-result message from index ${toolIdx} to ${i + 1} to immediately follow assistant tool-call(s) (${[...callIds].join(", ")}). ${toolIdx - i - 1} message(s) were wedged between them.`
+      );
+    }
+    i++;
+  }
+  return mutated ? result : messages;
+}
 function repairToolPairing(messages) {
   const toolCallIds = /* @__PURE__ */ new Set();
   const toolResultIds = /* @__PURE__ */ new Set();
@@ -8321,6 +8370,7 @@ ${summaryContent}`
           ];
         }
         messages = repairToolPairing(messages);
+        messages = ensureToolResultsFollowCalls(messages);
         messages = ensureEndsWithUserOrTool(messages);
         return messages;
       }
@@ -8515,7 +8565,7 @@ ${summaryContent}`
         }
       }
       async addResponseMessages(messages) {
-        const safe = repairToolPairing(messages);
+        const safe = ensureToolResultsFollowCalls(repairToolPairing(messages));
         await messageQueries.addMany(this.sessionId, safe);
         try {
           const { appendTurn: appendTurn2, flattenContent: flattenContent2 } = await Promise.resolve().then(() => (init_conversation_archive(), conversation_archive_exports));
@@ -10626,7 +10676,7 @@ ${prompt}` });
         const config = getConfig();
         const userContent = this.buildUserMessageContent(options.prompt, options.attachments);
         if (!options.skipSaveUserMessage) {
-          this.context.addUserMessage(userContent);
+          await this.context.addUserMessage(userContent);
         }
         await sessionQueries.updateStatus(this.session.id, "active");
         let systemPrompt = await buildSystemPrompt({
@@ -10674,9 +10724,10 @@ ${personality.trim()}`;
           // aborted mid-tool). Repairing in `prepareStep` guarantees no orphan
           // ever reaches the model and we never hit AI_MissingToolResultsError.
           prepareStep: async ({ messages: stepMessages }) => {
-            const repaired = repairToolPairing(stepMessages);
-            if (repaired === stepMessages) return {};
-            return { messages: repaired };
+            const paired = repairToolPairing(stepMessages);
+            const ordered = ensureToolResultsFollowCalls(paired);
+            if (ordered === stepMessages) return {};
+            return { messages: ordered };
           },
           onStepFinish: async (step) => {
             options.onStepFinish?.(step);
@@ -10689,7 +10740,7 @@ ${personality.trim()}`;
           const result = await stream;
           const response = await result.response;
           const responseMessages = response.messages;
-          this.context.addResponseMessages(responseMessages);
+          await this.context.addResponseMessages(responseMessages);
         };
         return {
           sessionId: this.session.id,
@@ -10703,7 +10754,7 @@ ${personality.trim()}`;
        */
       async run(options) {
         const config = getConfig();
-        this.context.addUserMessage(options.prompt);
+        await this.context.addUserMessage(options.prompt);
         const systemPrompt = await buildSystemPrompt({
           workingDirectory: this.session.workingDirectory,
           skillsDirectories: config.resolvedSkillsDirectories,
@@ -10727,13 +10778,14 @@ ${personality.trim()}`;
           } : void 0,
           // Repair tool pairing before every step (see `stream()` for full rationale).
           prepareStep: async ({ messages: stepMessages }) => {
-            const repaired = repairToolPairing(stepMessages);
-            if (repaired === stepMessages) return {};
-            return { messages: repaired };
+            const paired = repairToolPairing(stepMessages);
+            const ordered = ensureToolResultsFollowCalls(paired);
+            if (ordered === stepMessages) return {};
+            return { messages: ordered };
           }
         });
         const responseMessages = result.response.messages;
-        this.context.addResponseMessages(responseMessages);
+        await this.context.addResponseMessages(responseMessages);
         return {
           text: result.text,
           steps: result.steps
@@ -10916,9 +10968,10 @@ ${p.text}` : p.text;
             // See the matching note in `stream()` — repair tool pairing before
             // every step so we never feed the model an orphan tool-call.
             prepareStep: async ({ messages: stepMessages }) => {
-              const repaired = repairToolPairing(stepMessages);
-              if (repaired === stepMessages) return {};
-              return { messages: repaired };
+              const paired = repairToolPairing(stepMessages);
+              const ordered = ensureToolResultsFollowCalls(paired);
+              if (ordered === stepMessages) return {};
+              return { messages: ordered };
             },
             onStepFinish: async (step) => {
               options.onStepFinish?.(step);
@@ -13014,31 +13067,44 @@ async function recoverFromMissingToolResults(sessionId, error) {
   } catch (err) {
     console.warn("[missing-tool-recovery] could not load messages:", err?.message || err);
   }
-  const toolNameByCallId = /* @__PURE__ */ new Map();
+  const toolInfoByCallId = /* @__PURE__ */ new Map();
+  const resultMessageIndexByCallId = /* @__PURE__ */ new Map();
   const existingResultIds = /* @__PURE__ */ new Set();
-  for (const msg of history) {
+  for (let idx = 0; idx < history.length; idx++) {
+    const msg = history[idx];
     if (!Array.isArray(msg.content)) continue;
     for (const part of msg.content) {
       if (part?.type === "tool-call" && typeof part.toolCallId === "string") {
-        if (typeof part.toolName === "string") toolNameByCallId.set(part.toolCallId, part.toolName);
+        if (typeof part.toolName === "string") {
+          toolInfoByCallId.set(part.toolCallId, { toolName: part.toolName, callMessageIndex: idx });
+        }
       }
       if (part?.type === "tool-result" && typeof part.toolCallId === "string") {
         existingResultIds.add(part.toolCallId);
+        resultMessageIndexByCallId.set(part.toolCallId, idx);
       }
     }
   }
-  const resolved = toolCallIds.map((id) => ({
-    toolCallId: id,
-    toolName: toolNameByCallId.get(id) ?? "unknown",
-    foundInAssistantMessage: toolNameByCallId.has(id)
-  }));
+  const resolved = toolCallIds.map((id) => {
+    const info = toolInfoByCallId.get(id);
+    const resultIdx = resultMessageIndexByCallId.get(id);
+    const wedgedRoles = info && typeof resultIdx === "number" && resultIdx > info.callMessageIndex + 1 ? history.slice(info.callMessageIndex + 1, resultIdx).map((m) => m.role) : void 0;
+    return {
+      toolCallId: id,
+      toolName: info?.toolName ?? "unknown",
+      foundInAssistantMessage: !!info,
+      callMessageIndex: info?.callMessageIndex,
+      resultMessageIndex: resultIdx,
+      wedgedMessageRoles: wedgedRoles
+    };
+  });
   const stillOrphaned = toolCallIds.filter((id) => !existingResultIds.has(id));
   let syntheticToolMessageSaved = false;
   if (stillOrphaned.length > 0) {
     const syntheticParts = stillOrphaned.map((id) => ({
       type: "tool-result",
       toolCallId: id,
-      toolName: toolNameByCallId.get(id) ?? "unknown",
+      toolName: toolInfoByCallId.get(id)?.toolName ?? "unknown",
       output: {
         type: "text",
         value: "[Auto-recovered: the original tool execution never produced a result (crash, timeout, or message stripped during context compaction). This synthetic placeholder lets the conversation continue.]"
@@ -13055,15 +13121,49 @@ async function recoverFromMissingToolResults(sessionId, error) {
     }
   }
   const lastFewMessageRoles = history.slice(-6).map((m) => m.role);
+  const first = resolved.find((r) => r.callMessageIndex !== void 0);
+  let contextSnapshot;
+  if (first?.callMessageIndex !== void 0) {
+    const start = Math.max(0, first.callMessageIndex - 1);
+    const end = Math.min(
+      history.length,
+      Math.max(first.callMessageIndex, first.resultMessageIndex ?? first.callMessageIndex) + 2
+    );
+    contextSnapshot = history.slice(start, end).map((m, offset) => ({
+      index: start + offset,
+      role: m.role,
+      summary: summarizeContent(m.content)
+    }));
+  }
+  const anyWedged = resolved.some((r) => r.wedgedMessageRoles && r.wedgedMessageRoles.length > 0);
   return {
     kind: "missing_tool_results",
     toolCallIds,
     resolved,
     syntheticToolMessageSaved,
     lastFewMessageRoles,
-    hint: syntheticToolMessageSaved ? "Synthetic tool-result(s) saved. Re-send your message to continue." : "Could not auto-recover; please reset the session or revert to the previous checkpoint."
+    contextSnapshot,
+    hint: anyWedged ? "A non-tool message was wedged between the assistant tool-call and its tool-result (likely a Slack/system inbox event that arrived mid-turn). " + (syntheticToolMessageSaved ? "Synthetic tool-result was added as a fallback, but the proper fix (now in place) is the reordering pass that moves tool-results to immediately follow their tool-calls." : "The reordering pass should fix this on the next turn; if not, revert to the previous checkpoint.") : syntheticToolMessageSaved ? "Synthetic tool-result(s) saved. Re-send your message to continue." : "Could not auto-recover; please reset the session or revert to the previous checkpoint."
   };
 }
+function summarizeContent(content) {
+  if (typeof content === "string") {
+    return content.length > 160 ? content.slice(0, 160) + "\u2026" : content;
+  }
+  if (!Array.isArray(content)) return String(content);
+  const parts = content.map((p) => {
+    if (!p || typeof p !== "object") return String(p);
+    if (p.type === "text") {
+      const t = String(p.text ?? "");
+      return `text(${t.length > 80 ? t.slice(0, 80) + "\u2026" : t})`;
+    }
+    if (p.type === "tool-call") return `tool-call(${p.toolName}:${p.toolCallId})`;
+    if (p.type === "tool-result") return `tool-result(${p.toolName ?? "?"}:${p.toolCallId})`;
+    if (p.type === "reasoning") return "reasoning";
+    return p.type ?? "unknown";
+  });
+  return parts.join(", ");
+}
 
 // src/server/routes/agents.ts
 init_agent();