@ouro.bot/cli 0.1.0-alpha.491 → 0.1.0-alpha.492

package/changelog.json

@@ -1,6 +1,14 @@
 {
   "_note": "This changelog is maintained as part of the PR/version-bump workflow. Agent-curated, not auto-generated. Agents read this file directly via read_file to understand what changed between versions.",
   "versions": [
+    {
+      "version": "0.1.0-alpha.492",
+      "changes": [
+        "Engine-level fix for the actual root cause of Slugger's empty-reply MCP bug (PR #611's strip+retry was the right shape, but missed the deepest layer). MiniMax-M2.7 occasionally emits an assistant message with BOTH inline `<think>...</think>` reasoning AND tool_calls. When that combination is replayed in a subsequent turn, MiniMax rejects with error 2013 ('tool result's tool id not found') and stalls the entire session — every subsequent turn fails the same way, the failover layer fires repeatedly suggesting a provider switch, and the agent's own answer never reaches the operator. Slugger's session was stuck for 11 unanswered user messages because of this exact loop.",
+        "The fix has two halves and an AX rule: (1) **Persist-time strip** — runAgent now strips `<think>` blocks from the assistant message's persisted `content` before saving, while preserving the original reasoning trace on `_inline_reasoning` for audit. New `engine.inline_reasoning_stripped` info-level nerve event fires when this happens. (2) **Load-time repair** — `sanitizeProviderMessages` self-heals existing sessions that were saved before (1) by stripping the same blocks at load time. (3) **AX rule: full agent awareness, no silent fixes**. When the load-time repair runs, the synthetic tool-result that fills in for the missing tool result is an **explanatory** one — it tells the agent specifically: \"your previous tool call's result was lost because the assistant message had inline reasoning blocks the provider rejected; the harness has stripped them; your reasoning trace is preserved out-of-band; if the work needs to be done, retry the tool call now.\" Tool calls whose parent didn't have stripped reasoning still get a generic-but-improved \"this tool call's result was lost — possible causes [...]; retry if needed\" message instead of the old vague \"interrupted (previous turn timed out)\" line. The agent always sees what happened and what to do next.",
+        "Also: the no-tool-call retry path (added in #611's last commit) now uses the same shared `stripThinkBlocksForViolationCheck` helper so the violation-detection logic is consistent. Three regression tests cover the full path: persist-time strip preserves `_inline_reasoning`, load-time repair produces the explanatory tool-result message, generic orphans get the generic message, and unclosed `<think>` tags drop everything from the open tag onward."
+      ]
+    },
     {
       "version": "0.1.0-alpha.491",
       "changes": [

package/dist/heart/core.js

@@ -403,10 +403,13 @@ function repairOrphanedToolCalls(messages) {
         }
         const missing = asst.tool_calls.filter((tc) => !resultIds.has(tc.id));
         if (missing.length > 0) {
+            // AX rule: the agent must see what happened. Don't say "interrupted"
+            // — that's vague. Tell them the result was lost, possible causes,
+            // and what to do next.
             const syntheticResults = missing.map((tc) => ({
                 role: "tool",
                 tool_call_id: tc.id,
-                content: "error: tool call was interrupted (previous turn timed out or was aborted)",
+                content: "error: this tool call's result was lost — the previous turn ended before the tool finished (provider rejection, daemon interrupt, or the tool itself errored). if the work needs to be done, retry the tool call now.",
             }));
             let insertAt = i + 1;
             while (insertAt < messages.length && messages[insertAt].role === "tool")
@@ -764,8 +767,36 @@ async function runAgent(messages, callbacks, channel, signal, options) {
             const msg = {
                 role: "assistant",
             };
-            if (result.content)
-                msg.content = result.content;
+            // Persist assistant content WITHOUT inline <think>...</think> blocks.
+            // Reasoning content already routed through onReasoningChunk for live
+            // surfacing and persisted separately as `_reasoning_items` for
+            // providers that support a reasoning channel; saving it inline AND
+            // alongside tool_calls causes MiniMax to reject the replayed turn
+            // with "tool result's tool id not found" (error code 2013) because
+            // it can't reconcile reasoning-with-tools in the same assistant
+            // message. Strip aggressively at persist so the next replay is
+            // clean; preserve the original reasoning trace on the message via
+            // `_inline_reasoning` so debug/audit paths can still see it.
+            if (result.content) {
+                const stripped = stripThinkBlocksForViolationCheck(result.content);
+                if (stripped.length > 0)
+                    msg.content = stripped;
+                if (stripped.length !== result.content.length) {
+                    msg._inline_reasoning = result.content;
+                    (0, runtime_1.emitNervesEvent)({
+                        level: "info",
+                        component: "engine",
+                        event: "engine.inline_reasoning_stripped",
+                        message: "stripped inline <think> blocks from persisted assistant message; preserved on _inline_reasoning",
+                        meta: {
+                            provider: providerRuntime.id,
+                            model: providerRuntime.model,
+                            originalLength: result.content.length,
+                            strippedLength: stripped.length,
+                        },
+                    });
+                }
+            }
             if (result.toolCalls.length)
                 msg.tool_calls = result.toolCalls.map((tc) => ({
                     id: tc.id,

package/dist/heart/session-events.js

@@ -334,7 +334,7 @@ function repairSessionMessages(messages) {
     });
     return result.map(toProviderMessage);
 }
-function repairToolCallSequences(messages) {
+function repairToolCallSequences(messages, inlineReasoningStrippedCallIds = new Set()) {
     const normalized = messages.map(normalizeMessage);
     const validCallIds = new Set();
     for (const msg of normalized) {
@@ -381,7 +381,7 @@ function repairToolCallSequences(messages) {
             continue;
         const syntheticResults = missing.map((toolCall) => ({
             role: "tool",
-            content: "error: tool call was interrupted (previous turn timed out or was aborted)",
+            content: buildSyntheticToolResultMessage(toolCall.id, inlineReasoningStrippedCallIds),
             name: null,
             toolCallId: toolCall.id,
             toolCalls: [],
@@ -460,6 +460,105 @@ function migrateToolNames(messages) {
     }
     return safeMessages.map(normalizeMessage).map(toProviderMessage);
 }
+/**
+ * Strip inline `<think>...</think>` blocks from a string. Mirrors the
+ * helper at senses/shared-turn.ts (operator-facing) and core.ts
+ * (live-turn) — kept inline here because session-events.ts is the load-
+ * time repair path and needs its own copy to avoid sense/heart import
+ * cycles. If the close tag is missing, drops everything from the open
+ * tag onward.
+ */
+function stripInlineThinkBlocks(input) {
+    let out = input;
+    for (;;) {
+        const open = out.indexOf("<think>");
+        if (open === -1)
+            break;
+        const close = out.indexOf("</think>", open + "<think>".length);
+        if (close === -1) {
+            out = out.slice(0, open);
+            break;
+        }
+        out = out.slice(0, open) + out.slice(close + "</think>".length);
+    }
+    return out.trim();
+}
+/**
+ * Strip inline `<think>` content from any assistant message that ALSO has
+ * tool_calls. MiniMax-style models persist think-content + tool_calls on
+ * the same assistant turn; replaying that combination triggers MiniMax
+ * error 2013 ("tool result's tool id not found") and stalls the session.
+ *
+ * AX requirement: the agent MUST see that this happened. We don't silently
+ * paper over their previous turn — we strip for replay correctness AND
+ * collect the affected tool_call_ids in `inlineReasoningStrippedCallIds`
+ * so the downstream synthetic-tool-result repair can produce an
+ * explanatory message addressed to those specific calls. The agent sees:
+ * "your previous tool call's result was lost because the assistant message
+ * had inline reasoning blocks the provider couldn't replay — here's what
+ * happened, retry if needed." Full awareness, no silent corrections.
+ *
+ * This load-time repair self-heals existing sessions that were saved
+ * before the persist-time strip in core.ts landed.
+ */
+function repairInlineReasoningOnReplay(messages, inlineReasoningStrippedCallIds) {
+    let repaired = 0;
+    const result = messages.map((msg) => {
+        if (msg.role !== "assistant")
+            return msg;
+        const a = msg;
+        if (!a.tool_calls || a.tool_calls.length === 0)
+            return msg;
+        if (typeof a.content !== "string")
+            return msg;
+        if (!a.content.includes("<think>"))
+            return msg;
+        const stripped = stripInlineThinkBlocks(a.content);
+        repaired++;
+        for (const tc of a.tool_calls)
+            inlineReasoningStrippedCallIds.add(tc.id);
+        return { ...a, content: stripped.length > 0 ? stripped : null };
+    });
+    if (repaired > 0) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "info",
+            event: "mind.session_inline_reasoning_repair",
+            component: "mind",
+            message: "stripped inline <think> blocks from assistant messages with tool_calls so replay is valid; agent will see explanatory tool-result messages",
+            meta: { repaired, affectedCallIds: inlineReasoningStrippedCallIds.size },
+        });
+    }
+    return result;
+}
+/**
+ * Compose the synthetic tool-result message the agent sees when their
+ * previous turn's tool call has no matching tool result. The default
+ * message tells the agent what happened (turn ended early, result lost)
+ * and what to do (retry if the work isn't done). When the parent
+ * assistant message had inline `<think>` reasoning that the provider
+ * rejected, the message is more specific so the agent can adjust.
+ *
+ * AX rule: every repair must produce a message the agent can read and
+ * act on. Silent strips are never OK.
+ */
+function buildSyntheticToolResultMessage(toolCallId, inlineReasoningStrippedCallIds) {
+    if (inlineReasoningStrippedCallIds.has(toolCallId)) {
+        return [
+            "error: this tool call's result was lost.",
+            "your previous assistant turn included inline `<think>...</think>` reasoning alongside tool_calls,",
+            "and the provider (likely MiniMax) rejects that combination on replay (error 2013).",
+            "the harness has stripped the inline reasoning from the persisted content so the next replay is valid;",
+            "your reasoning trace itself is preserved out-of-band and not lost.",
+            "if the underlying work still needs to be done, retry the tool call now —",
+            "the call may not have run, or it ran but the result didn't reach you.",
+        ].join(" ");
+    }
+    return [
+        "error: this tool call's result was lost — the previous turn ended before the tool finished",
+        "(provider rejection, daemon interrupt, or the tool itself errored).",
+        "if the work needs to be done, retry the tool call now.",
+    ].join(" ");
+}
 function sanitizeProviderMessages(messages) {
     const safeMessages = messages.filter((message) => Boolean(message) && typeof message === "object");
     const normalized = safeMessages.map(normalizeMessage);
@@ -473,7 +572,12 @@ function sanitizeProviderMessages(messages) {
             meta: { violations },
         });
     }
-    return canonicalizeSystemMessageSequence(migrateToolNames(repairToolCallSequences(repairSessionMessages(normalized.map(toProviderMessage)))));
+    // Track which tool_call_ids belonged to assistant messages whose inline
+    // reasoning we just stripped. The synthetic-tool-result repair downstream
+    // uses this set to produce an explanatory message for those calls so the
+    // agent has full awareness of what happened.
+    const inlineReasoningStrippedCallIds = new Set();
+    return canonicalizeSystemMessageSequence(migrateToolNames(repairToolCallSequences(repairInlineReasoningOnReplay(repairSessionMessages(normalized.map(toProviderMessage)), inlineReasoningStrippedCallIds), inlineReasoningStrippedCallIds)));
 }
 function stampIngressTime(msg) {
     msg._ingressAt = new Date().toISOString();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ouro.bot/cli",
-  "version": "0.1.0-alpha.491",
+  "version": "0.1.0-alpha.492",
   "main": "dist/heart/daemon/ouro-entry.js",
   "bin": {
     "cli": "dist/heart/daemon/ouro-bot-entry.js",