Summary

• Problem: On 2026.4.15, mistral/mistral-small-latest with reasoning enabled streams delta.content as an Anthropic-style typed-block array ([{type:"thinking", thinking:[…]}, {type:"text", text:"…"}]) instead of a string. The OpenAI-completions stream parser at src/agents/openai-transport-stream.ts:1121 did currentBlock.text += choice.delta.content, which JS coerces to "" + [obj, obj] → literal "[object Object][object Object]…" tokens that surfaced before the real assistant answer (and matched corrupted text_delta events on the wire).
• Why it matters: Any OpenAI-compatible provider that emits typed-block content arrays (Mistral with reasoning_effort enabled is the immediate trigger; the same shape can appear from other providers that mirror Anthropic content blocks behind an OpenAI-completions endpoint) shipped corrupted output to the user. The thinking content was not surfaced at all (it lived inside the array blocks the parser threw away), and the visible answer was prefixed with junk [object Object] runs.
• What changed: Added unpackOpenAICompletionsContent next to getCompletionsReasoningDelta. Plain string delta.content keeps the existing fast path. Array delta.content is unpacked: {type:"text", text} blocks are concatenated into a real text delta and routed through the existing text-block append path; {type:"thinking", thinking} blocks (string thinking and nested thinking:[{type:"text", text}] shape both supported) are routed through the existing appendThinkingDelta path with the same pendingThinkingDelta interleaving guard the reasoning-field branch uses for tool-call chunks. Unknown truthy non-string shapes fall through to the reasoning/tool_calls branches instead of being coerced into assembled text.
• What did NOT change (scope boundary): String delta.content keeps byte-identical behavior — no behavior change for OpenAI/OpenRouter/etc. callers that already streamed strings. Reasoning-field handling (reasoning_content / reasoning / reasoning_text / reasoning_details) is unchanged. Tool-call deltas are unchanged. No new providers, model definitions, transport wrappers, or schema changes.

Change Type (select all)

• Bug fix
• Feature
• Refactor required for the fix
• Docs
• Security hardening
• Chore/infra

Scope (select all touched areas)

• Gateway / orchestration
• Skills / tool execution
• Auth / tokens
• Memory / storage
• Integrations
• API / contracts
• UI / DX
• CI/CD / infra

Linked Issue/PR

• Closes [Bug]: A problem with mistral small thinking enabled #68309
• This PR fixes a bug or regression

Root Cause (if applicable)

• Root cause: processOpenAICompletionsStream assumed choice.delta.content was always a string. Mistral-small-latest with reasoning enabled (and other OpenAI-compatible providers that proxy Anthropic-style content) emits it as a typed-block array, which JS string concatenation turned into literal [object Object] tokens in both currentBlock.text and the streamed text_delta event.
• Missing detection / guardrail: No type guard before text += and no unpacker for the typed-block array shape that several reasoning-capable OpenAI-compat providers now emit.
• Contributing context (if known): Mistral's mistral-small-latest with reasoning_effort enabled is the common trigger; the parser already handles other reasoning shapes (reasoning_details was added recently for OpenRouter/Qwen3) but didn't cover reasoning carried inside delta.content.

Regression Test Plan (if applicable)

• Coverage level that should have caught this:
  • Unit test
  • Seam / integration test
  • End-to-end test
  • Existing coverage already sufficient
• Target test or file: src/agents/openai-transport-stream.test.ts — new case unpacks Anthropic-style typed-block delta.content arrays without [object Object] coercion.
• Scenario the test should lock in: A 3-chunk Mistral-shaped stream where chunk 1 carries delta.content = [{type:"thinking", thinking:[{type:"text", text:"Let me reason: "}, {type:"text", text:"step one."}]}], chunk 2 carries a mixed [{type:"thinking", thinking:" Step two."}, {type:"text", text:"Hello!"}] array, and chunk 3 carries a plain string " How can I help?" (verifying the legacy fast path still works). Asserts: assembled text equals "Hello! How can I help?", assembled thinking equals "Let me reason: step one. Step two.", and neither the assembled text nor any captured text_delta event contains the substring [object Object].
• Why this is the smallest reliable guardrail: The test exercises the exact failing parser path with the same chunk shape [Bug]: A problem with mistral small thinking enabled #68309 reports, including the fast-path mix, and pins both the assembled output and the on-the-wire text_delta events.
• Existing test that already covers this (if any): None. Adjacent handles reasoning_details from OpenRouter/Qwen3 in completions stream tests cover the top-level reasoning-field branch, not array-shaped delta.content.
• Verified the test fails on main without the fix: expected '[object Object][object Object],[object Object] How can I help?' not to contain '[object Object]'. Passes with the fix.

User-visible / Behavior Changes

Mistral (and any other OpenAI-compatible provider that emits Anthropic-style typed-block delta.content) reasoning replies now show the real model answer in the text channel and the reasoning content in the thinking channel, instead of [object Object]… prefix junk. No behavior change for providers that emit string delta.content.

Diagram (if applicable)

Before (Mistral reasoning, delta.content = [thinking, text]):
chunk -> "" + [{type:thinking,…},{type:text,…}] -> currentBlock.text = "[object Object][object Object]…"

After:
chunk -> unpackOpenAICompletionsContent(content) -> { thinkingDelta, textDelta }
       -> appendThinkingDelta(thinkingDelta) (unchanged path)
       -> currentBlock.text += textDelta       (unchanged path)

Security Impact (required)

• New permissions/capabilities? (No)
• Secrets/tokens handling changed? (No)
• New/changed network calls? (No)
• Command/tool execution surface changed? (No)
• Data access scope changed? (No)

Repro + Verification

Environment

• OS: macOS (issue reporter Ubuntu 24.04)
• Runtime/container: local dev tree
• Model/provider: mistral/mistral-small-latest via openai-completions
• Integration/channel (if any): assistant text reply path
• Relevant config (redacted): mistral provider with reasoning_effort enabled

Steps

1. Stream chunks where choice.delta.content is an Anthropic-style typed-block array containing {type:"thinking", thinking:[…]} and {type:"text", text:"…"} blocks.
2. Observe assembled output.content[].text and the emitted text_delta events.

Expected

• No [object Object] substrings in assembled text or in any text_delta event.
• Thinking text appears in a thinking block; user-visible text appears in a text block.

Actual

• Without the fix: assembled text reads "[object Object][object Object],[object Object] How can I help?" and matching text_delta events carry the same junk.
• With the fix: assembled text reads "Hello! How can I help?"; thinking reads "Let me reason: step one. Step two.".

Evidence

• Failing test/log before + passing after

Stash the fix, keep the new test, run the scoped suite:

node scripts/test-projects.mjs src/agents/openai-transport-stream.test.ts
…
× unpacks Anthropic-style typed-block delta.content arrays without [object Object] coercion
   AssertionError: expected '[object Object][object Object],[object Object] How can I help?' not to contain '[object Object]'

Re-apply the fix, rerun:

node scripts/test-projects.mjs src/agents/openai-transport-stream.test.ts
 Test Files  1 passed (1)
      Tests  56 passed (56)

Human Verification (required)

• Verified scenarios:
  • Targeted suite node scripts/test-projects.mjs src/agents/openai-transport-stream.test.ts → 56/56 pass with fix; the new case fails on main without fix (reproduces the exact [object Object] prefix users see).
  • Adjacent OpenRouter completions tests still green: node scripts/test-projects.mjs src/agents/pi-embedded-runner/openrouter-model-capabilities.test.ts src/agents/pi-embedded-runner/extra-params.openrouter-cache-control.test.ts (62 tests, all pass).
  • Adjacent simple-completion runtime selection: node scripts/test-projects.mjs src/agents/simple-completion-runtime.selection.test.ts (6 tests, all pass).
• Edge cases checked:
  • Plain string delta.content preserves byte-identical behavior (existing OpenRouter/Qwen3 reasoning + string content test still passes; covered explicitly in chunk 3 of the new test).
  • delta.content = "" (empty string) keeps the original truthy gate — falls through to reasoning/tool_calls branches as before.
  • Truthy unknown non-string non-array shapes fall through to the reasoning / tool_calls branches instead of being coerced to assembled text (regression that previously masked into text += "[object Object]").
  • Mistral two thinking shapes covered: thinking as a string and thinking as a nested [{type:"text", text}] array.
• What I did not verify:
  • End-to-end live Mistral API call (no Mistral API key available locally; reproduced the exact byte-level shape via mocked responseStream).
  • Other OpenAI-compatible providers that may emit typed-block delta.content (the unpacker is shape-driven, not provider-gated, so any provider that emits the same shape benefits).

Review Conversations

• I replied to or resolved every bot review conversation I addressed in this PR.
• I left unresolved only the conversations that still need reviewer or maintainer judgment.

Compatibility / Migration

• Backward compatible? (Yes)
• Config/env changes? (No)
• Migration needed? (No)

Risks and Mitigations

• Risk: Some OpenAI-compatible provider could emit a typed block with type other than text/thinking that today silently coerces into [object Object] and that some downstream consumer accidentally pattern-matches on.
  • Mitigation: unrecognized block types are skipped (not coerced); unpacked.recognized stays true for the array shape so the fall-through to reasoning/tool_calls is reserved for non-array, non-string shapes only. The pre-fix behavior for those rare shapes was text += "[object Object]", which is strictly worse.
• Risk: delta.content = "" was previously falsy and skipped the content branch; this PR keeps the original truthy gate, so empty strings still skip and reasoning/tool_calls in the same chunk still process.
  • Mitigation: if (choice.delta.content) retained verbatim.

This PR was AI-assisted (Claude).