fix(providers): coalesce consecutive Thinking blocks in collect_stream

[Wolfe-Jam]

Fixes #11305

Summary

Conversation::push already coalesces consecutive thinking deltas by chunk id (added in #9162), but collect_stream — the default path every Provider::complete() call goes through — only has a coalescing arm for Text blocks. Thinking deltas fall through to the wildcard arm and are persisted one streamed chunk per content block.

This is a storage/serialization defect, not a correctness or token-cost one: formats/openai.rs concatenates thinking blocks with no separator, so N fragments and one merged block produce byte-identical model input, and token_counter never counts Thinking at all. But on a real session it's a real blow-up — the issue measured 12,632 fragmented content items collapsing to 249 once coalesced, a 50x reduction in content_json bytes.

Adds the same signature-aware merge rule collect_stream's Text arm already applies, mirroring Conversation::push's rule exactly: append while the previous block is unsigned or shares the incoming signature; never merge two distinctly-signed blocks.

Testing

• cargo test -p goose-provider-types --lib — 527 passed, 0 failed
• cargo clippy -p goose-provider-types --all-targets — clean, 0 warnings
• cargo fmt --check — clean
• cargo check -p goose — downstream crate (where the reported real-world impact lives, via tool-pair compaction) compiles clean against the change
• Two new tests: test_collect_stream_coalesces_thinking_deltas (the regression test from the issue, verbatim) and test_collect_stream_never_merges_distinctly_signed_thinking_blocks (the signature-boundary edge case from the expected-behavior spec)

[chatgpt-codex-connector]

💡 Codex Review

Here are some automated review suggestions for this pull request.

Reviewed commit: a2034121e6

ℹ️ About Codex in GitHub

Your team has set up Codex to review pull requests in this repo. Reviews are triggered when you

• Open a pull request for review
• Mark a draft as ready
• Comment "@codex review".

If Codex has suggestions, it will comment; otherwise it will react with 👍.

Codex can also answer questions or update the PR. Try commenting "@codex address that feedback".

[chatgpt-codex-connector]

Preserve multi-block Thinking boundaries

When a stream chunk contains more than one content block and starts with Thinking, this arm now merges that block into the previous Thinking whenever the previous signature is empty or matches. Conversation::push deliberately applies the analogous signature rule only for single-content delta messages, so a multi-block message can remain a complete block plus adjacent content. For inputs like an unsigned previous Thinking followed by [Thinking("next", "sig"), Text(...)], collect_stream will produce one signed thinking block covering both texts, corrupting the thinking/signature boundary; please gate this merge on the incoming message having exactly one content block or otherwise preserve multi-block boundaries.

Useful? React with 👍 / 👎.

[DOsinga]

The core merge rule is correct for single-content deltas, but this does not yet mirror Conversation::push for multi-content chunks.

collect_stream iterates each block of an incoming message and merges its first Thinking block into the prior message regardless of how many blocks the incoming message contains. Conversation::push intentionally requires message.content.len() == 1. For an unsigned prior thinking delta followed by a chunk shaped [Thinking("next", "sig"), Text(...)], this implementation signs the concatenation of the prior and new thinking text, erasing a block/signature boundary. Please retain the incoming content count and gate thinking coalescing on a single-content incoming message (or otherwise preserve the same boundary semantics).

Please also add direct collect_stream tests for: (1) unsigned body + signed closing delta adopts the signature, (2) signed thinking followed by unsigned thinking remains separate, and (3) a multi-content incoming message does not merge its thinking block into the prior block. The existing tests cover the basic unsigned case and two distinct non-empty signatures, but not the asymmetric signature-at-end cases or the multi-block constraint that exposed this issue.

[Wolfe-Jam]

Confirmed and fixed — reproduced the exact corruption first (stashed the guard, ran the multi-block test: prior + next merged into "priornext" signed "sig", matching what you described), then gated the Thinking arm on msg.content.len() == 1, mirroring Conversation::push's guard precisely.

Added the three tests you asked for: unsigned body adopting a closing signature, an unsigned delta after a signed block starting a new block, and the multi-block case that exposed the bug (verified failing without the fix, passing with it).

cargo test -p goose-provider-types --lib — 530 passed, 0 failed. cargo clippy --all-targets and cargo fmt --check clean.

— Assisted by Claude · Approved by James Wolfe (@Wolfe-Jam)

Feedback addressed