fix(agents): handle nested Mistral thinking-block arrays and add changelog credit

lonexreb · lonexreb · commit 4ebe0cedc052 · 2026-05-05T13:11:11.000-05:00
Round-1 review on PR #75339 caught two gaps: 1. Nested thinking arrays were dropped. The original normalizer only read `record.thinking` as a string, but the Mistral typed-block reproduction includes `type:"thinking"` blocks whose `thinking` value is itself an array of `{type:"text", text:"..."}` parts. Recurse into nested text/thinking/content arrays-and-objects, then re-tag the resulting parts as thinking when the outer block declared a thinking-style type (`thinking`, `reasoning`, or `reasoning.text`). Same recursion is safe for nested `text` and `content` shapes — they fall through as text deltas. 2. Missing CHANGELOG entry. Add an Unreleased `### Fixes` bullet with contributor credit per the repo policy in CLAUDE.md ("every added entry must include at least one Thanks @author attribution"). Add 4 round-2 regression tests: - type:thinking block with thinking: [array of text parts] flattens to per-part thinking deltas keyed on the outer signature - type:reasoning block with text: [array of text parts] flattens to per-part thinking deltas - untyped block with content: [array of text parts] flattens to text - nested thinking block with only empty sub-blocks returns no parts (the "never emit [object Object]" invariant still holds for the recursive case) Refs #75268, #70806
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -70,6 +70,7 @@ Docs: https://docs.openclaw.ai
 
 ### Fixes
 
+- Agents/openai-completions: normalize structured `delta.content` blocks (including nested Mistral thinking-block arrays) at the shared OpenAI-compatible stream boundary so non-string content does not surface as `[object Object]` in chat replies, transcripts, and memory. Fixes #75268. Thanks @lonexreb.
 - Gateway/OpenAI-compatible: send the assistant role SSE chunk as soon as streaming chat-completion headers are accepted, so cold agent setup cannot leave `/v1/chat/completions` clients with a bodyless 200 response until their idle timeout fires.
 - Agents/media: avoid direct generated-media completion fallback while the announce-agent run is still pending, so async video and music completions do not duplicate raw media messages. (#77754)
 - TUI/sessions: bound the session picker to recent rows and use exact lookup-style refreshes for the active session, so dusty stores no longer make TUI hydrate weeks-old transcripts before becoming responsive. Thanks @vincentkoc.
diff --git a/src/agents/openai-transport-stream.test.ts b/src/agents/openai-transport-stream.test.ts
@@ -4498,4 +4498,48 @@ describe("normalizeStructuredContentDelta", () => {
       ]),
     ).toEqual([{ kind: "text", text: "kept" }]);
   });
+
+  // Round-2 regression for #75268: a `type:"thinking"` block can carry its
+  // payload as a nested array of typed text sub-blocks instead of a flat
+  // string. Recursively flatten and re-tag as thinking.
+  it("flattens a nested thinking block whose `thinking` value is an array of text parts", () => {
+    expect(
+      normalizeStructuredContentDelta({
+        type: "thinking",
+        thinking: [
+          { type: "text", text: "step one " },
+          { type: "text", text: "step two" },
+        ],
+      }),
+    ).toEqual([
+      { kind: "thinking", signature: "thinking", text: "step one " },
+      { kind: "thinking", signature: "thinking", text: "step two" },
+    ]);
+  });
+
+  it("flattens a nested reasoning block whose `text` value is an array of text parts", () => {
+    expect(
+      normalizeStructuredContentDelta({
+        type: "reasoning",
+        text: [{ type: "text", text: "internal thought" }],
+      }),
+    ).toEqual([{ kind: "thinking", signature: "reasoning", text: "internal thought" }]);
+  });
+
+  it("flattens a nested untyped block whose `content` value is an array of text parts as text", () => {
+    expect(
+      normalizeStructuredContentDelta({
+        content: [{ type: "text", text: "visible reply" }],
+      }),
+    ).toEqual([{ kind: "text", text: "visible reply" }]);
+  });
+
+  it("returns no parts when a nested thinking block contains only empty sub-blocks", () => {
+    expect(
+      normalizeStructuredContentDelta({
+        type: "thinking",
+        thinking: [{ type: "text", text: "" }, { type: "text" }],
+      }),
+    ).toEqual([]);
+  });
 });
diff --git a/src/agents/openai-transport-stream.ts b/src/agents/openai-transport-stream.ts
@@ -1630,6 +1630,37 @@ function normalizeStructuredContentDelta(value: unknown): StructuredContentDelta
   if (typeof value === "object") {
     const record = value as Record<string, unknown>;
     const type = typeof record.type === "string" ? record.type : undefined;
+    const isThinkingType = type === "thinking" || type === "reasoning" || type === "reasoning.text";
+    // Mistral's typed-block reasoning shape can nest sub-blocks: a `type:"thinking"`
+    // block may carry `thinking: [{type:"text", text:"..."}, ...]` rather than a
+    // flat string. Recurse into nested arrays/objects, then re-tag the resulting
+    // text parts as thinking when the outer block declared a thinking-style type.
+    const nestedSource =
+      record.text !== undefined && record.text !== null && typeof record.text !== "string"
+        ? record.text
+        : record.thinking !== undefined &&
+            record.thinking !== null &&
+            typeof record.thinking !== "string"
+          ? record.thinking
+          : record.content !== undefined &&
+              record.content !== null &&
+              typeof record.content !== "string"
+            ? record.content
+            : undefined;
+    if (nestedSource !== undefined) {
+      const nested = normalizeStructuredContentDelta(nestedSource);
+      if (nested.length === 0) {
+        return [];
+      }
+      if (isThinkingType) {
+        return nested.map((part) => ({
+          kind: "thinking",
+          signature: type ?? "thinking",
+          text: part.text,
+        }));
+      }
+      return nested;
+    }
     const candidateText =
       typeof record.text === "string"
         ? record.text
@@ -1641,7 +1672,7 @@ function normalizeStructuredContentDelta(value: unknown): StructuredContentDelta
     if (!candidateText || candidateText.length === 0) {
       return [];
     }
-    if (type === "thinking" || type === "reasoning" || type === "reasoning.text") {
+    if (isThinkingType) {
       return [{ kind: "thinking", signature: type, text: candidateText }];
     }
     return [{ kind: "text", text: candidateText }];
