[Bug] rc.7: reasoning (thinking) intermittently stored and rendered as text blocks - thinking leaks into the visible transcript

[Start-Gao]

[Bug] rc.7: reasoning (thinking) intermittently stored and rendered as text blocks — thinking leaks into the visible transcript

Category: General (the repo has no Bug Report category; following the [Bug] title convention of #274)
Reporter environment: dsh 0.1.0-rc.7 (npm, commit 99f6f02fec), Web GUI at http://127.0.0.1:3080, Windows 11 x64, Node 24

---

1. Summary

On dsh 0.1.0-rc.7, in the Web GUI, some assistant turns have their reasoning content stored and rendered as a regular text block instead of a reasoning block. The thinking that should be folded under the "Think" disclosure appears inline in the transcript as normal text. It is intermittent: healthy turns dominate, but affected turns leak — sometimes entirely (the turn's reasoning-chunks event count drops to 0 and the thinking is projected into the text channel).

The misclassification is consistent across all three layers we inspected: the streaming chunk projection, the final stored assistant/message, and the replay metadata. The client rendering layer is ruled out (byte-identical reasoning dispatch in rc.6 vs rc.7 bundles). The assembly layer (BlockAssembler / the pi-ai adapter path) is the suspected seam.

2. Environment

• dsh 0.1.0-rc.7 (npm latest, commit 99f6f02fec), Web GUI on 127.0.0.1:3080
• Windows 11, Node v24
• Route: modlens-opencode-go / model deepseek-v4-flash, reasoningEffort: max (a pure-text model; the provider declares reasoning_content as the thinking signature)
• No config change between healthy and leaking turns (verified: request/header records are identical across turns in both sessions)

3. Symptom (user-visible)

In affected turns, a long block of English reasoning monologue appears as ordinary transcript text (rendered as markdown), instead of being collapsed under the "Think" disclosure. In one affected turn the leaked thinking was ~2,943 of a 3,027-character text block — i.e., the visible reply occupied only the last ~84 characters. In another observed case the reply itself was truncated at the per-turn output cap, consistent with the leaked thinking inflating the output.

4. Evidence

4.1 Session A — the first turn right after the rc.6→rc.7 GUI restart (2026-08-17, session log session-1cf6231b-…/session.jsonl.zstd)

Chunk-channel event counts per turn (parsed from the session record):

turn	reasoning-chunks	text-chunks	tool-call-chunks
1	462	120	present
2	183	52	present
3	48	17	present
4 (first turn after restart)	0	73	present
5	80	10	present

• Turn 4's streaming projection emitted zero reasoning-chunks and 73 text-chunks — the reasoning stream was folded into the text channel.
• The final stored assistant/message for turn 4 has no reasoning block in any step; content shape is [text, tool-call] (e.g. seq 17259, 17820, 17946). The step-1 text block is 3,027 characters: ~2,943 characters of English thinking + the ~84-character visible reply at the tail.
• The stored replayState.blocks for those messages is [text, tool-call] — the reasoning entry is missing there too (the same turn in the same session's earlier steps, e.g. seq 1733, shows blocks: [reasoning, text, tool-call]).
• Later turns of the same session (5+) went back to normal separation — which is why this was initially (and incorrectly) judged a one-time handover transient.

4.2 Session B — days later, stable rc.7 runtime, two agentic turns (2026-08-18, session log session-2cf17b41-…/session.jsonl.zstd)

Chunk-channel event counts for the affected neighborhood:

turn	reasoning-chunks	text-chunks	tool-call-chunks
155	56	15	5
156	22	15	0
157	20	11	5
158	34	19	8
159	10	168	52
160	26	17	0
161	0	18	32
162	92	11	23

• Turn 159: 168 text-chunks vs only 10 reasoning-chunks — the overwhelming majority of the turn's reasoning was projected into the text channel.
• Turn 161: reasoning-chunks = 0 — a total leak, same signature as Session A turn 4.
• Healthy neighbor turns (155–158, 160, 162) all have reasoning-dominant ratios.

Nine assistant/message entries in those two turns have content shape [text, tool-call, …] where the text block is the step's reasoning monologue and the step's actual visible reply is absent:

seq	turn.step	text block (head, first ~80 chars)	text len
487889	159.2	"Findings so far: 1. Current local state: dsh = 0.1.0-rc.7 ✅ …"	3,363
488828	159.3	"Two key findings: 1. dsh rc.7 release notes (official) …"	—
489267	159.4	"Now the picture is complete and important: 1. modlens has the SAME rc.7 breakage …"	—
490350	159.5	"Now the full picture is crystal clear. Let me synthesize: CRITICAL FINDING …"	—
490509	159.6	"Confirmed: 1. modlens 3.18.1's dsh/client.js line 799-800 …"	—
490883	159.7	"The paste.png was deleted earlier (we cleaned %TEMP% …)"	—
491444	159.9	"Decisive result: modlens vision tools WORK on dsh rc.7 …"	—
492265	161.1	"The user approved upgrading dshmarket via CLI. Execute the standard procedure: 1. Backup …"	—
492542	161.5	"Verified: dshmarket 1.12.1 installed, dependency ^1.12.1 …"	—

Full structure of one leaked message (seq 487889, turn 159 step 2):

assistant/message
├─ [text] len=3363   ← the step's reasoning monologue (leaked)
├─ [tool-call] len=892
└─ [tool-call] len=908
(no [reasoning] block)

These turns are hours after the restart and are ordinary multi-tool-call agentic turns — disproving the earlier "one-time handover transient" hypothesis.

5. Analysis

5.1 What is ruled out

• Rendering (client): rc.6 and rc.7 dsh-client-ui-conversation / dsh-client-ui-primitives bundles are byte-identical in ReasoningRow, DisclosureRow, and the case "reasoning" → <ReasoningRow> dispatch; the UI faithfully renders what it receives. A message without a reasoning block cannot show a folded Think row.
• Configuration: the request/header records for healthy and leaking turns are identical (provider: modlens-opencode-go, model: deepseek-v4-flash, reasoningEffort: max). Nothing changed between the healthy turn 5 (session A) and the leaking turn 4, nor between turn 158/160 and turn 159/161 (session B).
• The model simply "not thinking": the leaked text blocks contain the reasoning itself; the content exists, it is only mis-classified.

5.2 What is consistent with a classification bug in the assembly layer

The same signature appears at three layers for the same turn, all pointing at where streaming deltas are classified into block types:

1. Streaming projection: reasoning-chunks = 0 (or near-0) while text-chunks explodes.
2. Final storage: the assistant/message content has no reasoning block; the text block contains the thinking.
3. Replay metadata: replayState.blocks = [text, tool-call] — the reasoning entry is dropped there as well.

If the mis-tagging happened at render time, layers 1–3 would still contain the reasoning. They do not. The classification is lost before storage — i.e., in the BlockAssembler / adapter seam that maps the provider stream (including reasoning_content) to typed blocks.

5.3 Trigger pattern (inference, n=2 sessions)

All affected turns share two properties:

• Many sequential tool calls: 52 and 32 tool-call-chunks in the leaking turns of session B; healthy turns have 0–23.
• Long reasoning interleaved with the tool-call stream.

Session A's turn 4 also had tool calls in every step. The working hypothesis: when reasoning deltas and tool-call deltas interleave heavily in one turn, the seam that decides "this delta is reasoning vs text" loses the reasoning classification for spans around the interleaving, and those spans fall into the text block. The 10 surviving reasoning-chunks in turn 159 vs 0 in turn 161 suggest it is a boundary-dependent behavior, not a hard failure.

5.4 Relation to the replay refactor

Session A's turn 4 was the first model call of the new process — the exact point where the rc.7 ReplayEnvelope change (#2596, flat v1 replayState being taken over by the new envelope format) executes its handover. The v1→v2 transition is one candidate place where the reasoning entry of the envelope can be dropped while the text entry survives. This is consistent with the observed replayState.blocks = [text, tool-call].

6. Impact

• Privacy/noise: thinking becomes visible in the transcript for the affected turns.
• Output inflation → truncation: leaked thinking counts toward the message output; in one observed case the reply was truncated at the per-turn output cap.
• Not a session-killer: the session continues normally afterwards (the rc.7 max-token/replay fix works); the damage is contained to the affected turns.

7. Expected behavior

Reasoning streamed by the provider (reasoning_content) should be classified into reasoning blocks and folded under "Think" — for every turn shape, including multi-tool-call turns — matching healthy turns.

8. Suggested check points for maintainers

1. BlockAssembler (packages/llm/llm/src/assembler.ts) delta classification when a turn interleaves reasoning and tool-call streams; specifically how a reasoning span adjacent to tool-call boundaries is typed.
2. ReplayEnvelope (macOS: PTY persistent shell (official Minimal preset shell) hangs commands to the 300s timeout when command text contains CJK characters #2596) keep/drop decision: when the envelope's block entries are pruned (e.g., "max-tokens finish drops tool calls … and prunes envelope entries at dropped positions"), confirm a dropped reasoning entry cannot silently merge its text into the surviving text block.
3. The pi-ai adapter's reasoning/text seam for modlens-opencode-go-style routes (provider declares reasoning_content).

9. How to reproduce / verify locally

1. Decode a session log: node decode-session.mjs <session.jsonl.zstd> (fzstd).
2. Count chunk events per turn: leaking turns show reasoning-chunks ≈ 0 with inflated text-chunks.
3. Inspect assistant/message entries: leaking steps have content = [text, tool-call] with the text block containing English planning prose.
4. Check replayState.blocks: [text, tool-call] instead of [reasoning, text, tool-call].

10. Notes

• First observed 2026-08-17 on the first turn after the rc.6→rc.7 GUI restart; initially recorded locally as a one-time handover transient (§4.4 of the local upgrade record). The second occurrence (2026-08-18, stable runtime) disproves that.
• Session logs referenced above are available on request; I can attach decoded JSONL excerpts or produce a minimal reproduction if helpful.

[Start-Gao]

rc.1.2 复发数据点（2026-08-22，同签名，跨版本持续）

环境：Windows 11 25H2 / Node.js 24.14.0 / @deepseek-ai/dsh@0.1.1-rc.2 / 纯 opencode-go 路由（deepseek-v4-flash，modlens 变体在同一会话的下一轮正常）——证明与第三方插件无关，是组装层固有 bug。

指标	turn 22（复发）	turn 23（同会话对照）
reasoning-chunks	0	77
text-chunks	103	30
assistant/message	7	8
含 reasoning 块的消息	0 / 7	6/8（2 条为纯 tool-call 续步）

泄漏文本样例（存为标准 text 块，实为思考草稿；全英文流畅推理，与最终中文正式回复形成对照）：
"The user reports a REGRESSION after the rc.1.2 upgrade: - In this very session, using DeepSeek V4 Flash (modlens vision) — the variant model — sending messages now fails with: 本轮运行失败 registration.adapter.prepareCall is not a function..."

触发特征复现：多工具调用轮次 + 超长思考（本次为插件兼容调查轮，十余次工具调用、思考数千 token）——与首报及 §4.4 结论一致。

版本沿革：rc.7（首报）→ rc.1.1（重启后首轮未复现一次，样本 1）→ rc.1.2（复发，本数据点）。流式（reasoning-chunks=0）、存储（无 reasoning 块）、重放三层一致丢失，与首报机制相同。修复仍未进入任何发布版本。

[ZK-Andy]

+1 — reproduced on dsh 0.1.1-rc.2, Linux , Node 24

Same signature across all three layers (streaming / storage / replay):

Route: commandcode / deepseek/deepseek-v4-pro / reasoningEffort: high
Trigger: multi-tool-call agentic turns with long reasoning (~2k–4k tokens of thinking interleaved with 10+ tool calls)
Symptom: reasoning-chunks drops to 0, text-chunks inflates to 100+; the final assistant/message has no reasoning block — the entire thinking monologue appears inline as a regular text block
Affected turns recover in subsequent turns — same session, same config, no restart
Confirmed it is not the third-party provider plugin: the reasoning_effort parameter is sent correctly in the request body, and the provider returns reasoning_content SSE events. The misclassification happens inside the assembler layer.

One additional observation: in my case the leaked thinking text is entirely in a different language (Chinese thinking, English final reply), which makes the boundary very obvious — the text block starts with thousands of characters of Chinese reasoning followed by a short English answer at the tail.

This is a blocking issue for any reasoning model used through tool-heavy workflows. Looking forward to a fix in the BlockAssembler / ReplayEnvelope seam.

[denial123789]

I expanded an independent troubleshooting guide with this distinction: https://github.com/sandbaseai/deepseek-harness-handbook/blob/main/docs/en/troubleshooting/response-language-and-reasoning.md

It separates language preference from an assembler/channel-classification defect, and recommends comparing durable block shape plus chunk counts before changing prompts. The guide treats leaked reasoning as a privacy and output-budget issue until a release fixes the seam.