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

lonexreb · lonexreb · commit 8248b3e5835a · 2026-04-30T23:29:00.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
@@ -11,6 +11,7 @@ Docs: https://docs.openclaw.ai
 
 ### Fixes
 
+- Agents/OpenAI-completions stream: normalize structured `delta.content` and `reasoning_content` arrays of typed blocks (including nested Mistral `type:"thinking"` blocks whose `thinking` value is itself an array of text sub-blocks) so reasoning-capable Mistral models no longer produce `[object Object]` runs in user-visible chat replies, session transcripts, and memory. Fixes #75268; refs #70806. Thanks @lonexreb.
 - Agents/commitments: keep inferred follow-ups internal when heartbeat target is none, strip raw source text from stored commitments, disable tools during due-commitment heartbeat turns, bound hidden extraction queue growth, expire stale commitments, and add QA/Docker safety coverage. Thanks @vignesh07.
 - Plugins/runtime-deps: accept already materialized package-level runtime-deps supersets as converged, so later lazy plugin activation no longer prunes and relaunches `pnpm install` after gateway startup pre-staging, reducing event-loop pressure from repeated runtime-deps repair on packaged installs. Fixes #75283; refs #75297 and #72338. Thanks @brokemac79, @lisandromachado, and @midhunmonachan.
 - TTS/providers: keep bundled speech-provider compat fallback available when plugins are globally disabled, so cold gateway and CLI startup can still resolve fallback speech providers instead of leaving explicit TTS provider selection with no registered providers. Refs #75265. Thanks @sliekens.
diff --git a/src/agents/openai-transport-stream.test.ts b/src/agents/openai-transport-stream.test.ts
@@ -4202,4 +4202,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
@@ -1596,6 +1596,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
@@ -1607,7 +1638,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 }];
