[BUG] Desktop (Cowork/Code): showThinkingSummaries is ignored — thinking arrives empty (display: omitted) on Fable 5 / Opus 4.7+, "Thought process" panel permanently empty

Also have this problem. It looks something like this screenshot.

We see that the agent is thinking, and the number of tokens ticks up, but it cannot be expanded any more.
<img width="623" height="296" alt="Image" src="https://github.com/user-attachments/assets/00e140c9-dc6e-4965-946c-2abeec93cc73" />

It looks like an intentional change though, there are no error messages and everything else is working.

This must be fixed if we are to trust claude.

I had claude read through the VS code plugin, and look at log files, introspecting the conversation I'm having with it about this issue. Here are it's findings:

I can't include the actual transcript, but visual inspection does show that no thinking text has been sent. The VS code extension appears to work correctly, the problem is upstream and might be intentional.

Report: Why extended-thinking blocks show "Thought for Ns" but won't expand (Claude Code VS Code extension)

Environment: Claude Code VS Code extension anthropic.claude-code-2.1.210-win32-x64 (Windows).
Symptom: In the VS Code panel, a reasoning block renders as a static line — e.g. Thought for 332s — with no way to expand it and read the reasoning. The reasoning is not visible anywhere else in the UI.

Summary

Two facts combine, and only the second is the real gap:

1. The webview renderer has two pathways, selected by whether the thinking block it is handed contains text. Non-empty text renders an expandable <details> with the reasoning inside; empty/blank text renders a static, non-expandable label showing only the duration.

1. The blocks the client holds always have empty text. Every thinking block in the persisted session transcript is { type:"thinking", thinking:"", signature:"…" } — an opaque signature and a duration, but no words.

So the renderer correctly takes the static pathway: it is doing the right thing for empty input. "Thought for 332s, not expandable" is not a rendering bug — it is the correct output when there is no text. The reasoning plaintext is stripped or never delivered upstream of the client's stored state: it is absent from the transcript the host renders from, therefore also absent from whatever the host could forward to the webview. This is at the API/SDK layer, not the host-to-webview boundary, and it is not model output that this client ever sees in readable form.

Evidence

1. The transcript stores signatures, not reasoning text

Session transcript: ~/.claude/projects/c--projects-agents-meat-agent-workspace/<session-id>.jsonl

JSON-parsing every line and inspecting each type:"thinking" block:

thinking blocks:            138
blocks with empty thinking: 138
blocks with non-empty text:   0
keys on each block:         type, thinking, signature
signature length min/max:   412 / 17580

The shape of every block (signature truncated):

{
  "type": "thinking",
  "thinking": "",
  "signature": "Er0ECokBCA8YAipA5+YE+4A2zhjTl3xe0IPvvCp0C9vHZNq2…"   // 412–17580 chars, opaque
}

The signature is an encrypted token the model uses to verify and continue its own prior reasoning on later turns; it is not human-readable and does not contain the reasoning. Note that a naive grep -c '"type":"thinking"' counts block markers, not whether they carry text, and will mislead — a JSON parse is required, and it shows the text is empty in every case.

Consequence: the reasoning is not recoverable from the transcript. There is no plaintext to read or quote.

2. The extension is closed-source (minified bundle)

The extension ships as compiled, minified JavaScript with mangled identifiers — there is no public source for these internals:

• webview/index.js (~4.8 MB) — the React UI that renders the conversation.
• extension.js (~2.2 MB) — the extension host.

The renderer below was recovered by grepping the minified webview/index.js for the literal string Thought for.

The renderer and its two pathways

Raw (minified) — webview/index.js, the Thought for render site

function Vxe({thinkingBlock:e,context:t,isExpanded:i,onToggle:n,isCurrentlyThinking:o,durationMillis:r,liveThinkingTokenEstimate:s}){
  let[a,l]=ne(!1),c=i!==void 0?i:a,d=n!==void 0?n:l,
    u=o?"Thinking...":r!==null?`Thought for ${Math.round(r/1000)}s`:"Thinking",
    h=o&&s?b(klt,{estimate:s}):null;
  if(!e.thinking||!e.thinking.trim())
    return b("div",{className:`${hp.thinking} ${hp.thinkingV2}`,children:E("div",{className:`${hp.thinkingSummary} ${hp.thinkingStatic}`,children:[b("span",{children:u}),h]})});
  return E("details",{className:`${hp.thinking} ${hp.thinkingV2}`,open:c,onToggle:(p)=>d(p.target.open),children:[
    E("summary",{className:hp.thinkingSummary,children:[b("span",{children:u}),h,b(zxe,{className:`${hp.thinkingToggle} ${c?hp.thinkingToggleOpen:""}`})]}),
    b("div",{className:hp.thinkingContent,children:b(up,{content:e.thinking,context:t})})
  ]})
}

(b/E are the bundle's JSX-createElement helpers; ne is useState; up is the markdown renderer.)

De-minified for clarity

function ThinkingBlock({ thinkingBlock, context, isExpanded, onToggle,
                         isCurrentlyThinking, durationMillis, liveThinkingTokenEstimate }) {

  const [localOpen, setLocalOpen] = useState(false);
  const open   = isExpanded !== undefined ? isExpanded : localOpen;
  const toggle = onToggle   !== undefined ? onToggle   : setLocalOpen;

  const label =
      isCurrentlyThinking      ? "Thinking..." :
      durationMillis !== null  ? `Thought for ${Math.round(durationMillis / 1000)}s` :
                                 "Thinking";

  // ---- PATHWAY A: no reasoning text present ----
  if (!thinkingBlock.thinking || !thinkingBlock.thinking.trim()) {
    return (
      <div className="thinking thinkingV2">
        <div className="thinkingSummary thinkingStatic">   {/* static: no <details>, no toggle, no body */}
          <span>{label}</span>
        </div>
      </div>
    );
  }

  // ---- PATHWAY B: reasoning text present ----
  return (
    <details className="thinking thinkingV2" open={open} onToggle={e => toggle(e.target.open)}>
      <summary className="thinkingSummary">
        <span>{label}</span>
        <Chevron className={open ? "thinkingToggleOpen" : ""} />
      </summary>
      <div className="thinkingContent">
        <Markdown content={thinkingBlock.thinking} context={context} />
      </div>
    </details>
  );
}

Pathway A — static, non-expandable (the observed behaviour)

• Trigger: thinkingBlock.thinking is null, undefined, "", or whitespace-only.
• Renders: a plain <div> with class thinkingStatic containing only the label (Thought for 332s).
• No <details>, no <summary>, no toggle chevron, no content node. The reasoning body is never placed in the DOM, so there is nothing to expand.

Pathway B — expandable (the intended experience, not reached here)

• Trigger: thinkingBlock.thinking contains non-whitespace text.
• Renders: a native <details> element — a clickable <summary> (label + chevron) and a <div class="thinkingContent"> holding the reasoning as markdown.
• Expand/collapse works via the <details open> attribute, driven by controlled props (isExpanded/onToggle) or the local useState fallback.

Because the client's thinking blocks always have empty text (see Evidence 1), Pathway B is never reached for them; the panel always renders Pathway A.

Root cause

The webview renders the duration correctly and takes Pathway A because the block's thinking is empty — the renderer is behaving correctly for its input. The real gap is that the block never has text on the client side: the persisted transcript, which is the store the host renders from, holds only thinking:"" + signature. The plaintext is stripped or never delivered before it reaches anything the client can display.

Confidence:

• Confirmed (read from the shipped bundle): the two-pathway renderer and its exact empty-text condition.
• Confirmed (JSON-parsed on disk): 138 thinking blocks, all with empty thinking and a non-empty signature; none carry reasoning text.
• Confirmed: the reasoning plaintext is not recoverable from the transcript.
• Not determinable from the on-disk artifacts alone: which layer drops the plaintext, and whether it was ever present client-side. Candidates: (a) the API returns signature-only thinking to this SDK/effort configuration; (b) the Agent SDK / harness streams plaintext live but persists only the signature, discarding the text once the turn completes. Distinguishing these needs a network or stream capture.

Implications

• Reasoning that is billed and generated (e.g. 332s of it) is currently unauditable in the VS Code panel — it cannot be watched or reviewed there.
• It is not recoverable after the fact either: the transcript keeps only the signature and duration, not the words.
• This is closer to a content-retention gap than a display bug: the plaintext is not available client-side at all. Whether that is by design (privacy/size) or incidental is unconfirmed.

Workarounds

1. Watch it live in the terminal CLI — the CLI can stream thinking/tool events (verbose) as they happen. Unverified against this environment: if the CLI is subject to the same signature-only delivery it will not show plaintext either, so test it directly (run a task with verbose and see whether reasoning text appears).
2. Have the assistant reason in the open — lower effort and/or narrate a short plan before each step, so the reasoning lands in normal rendered text (which is retained and rendered) rather than a hidden thinking block. This is the only option fully under our control and immune to the retention gap.
3. Do not rely on the session .jsonl for reasoning — it contains signatures only.

Artifacts / references

• Renderer: ~/.vscode/extensions/anthropic.claude-code-2.1.210-win32-x64/webview/index.js (search Thought for).
• Host bundle (candidate strip point, unconfirmed): ~/.vscode/extensions/anthropic.claude-code-2.1.210-win32-x64/extension.js.
• Transcript (signatures only, no reasoning text): ~/.claude/projects/c--projects-agents-meat-agent-workspace/<session-id>.jsonl.
• Related upstream reports (thinking visibility is actively changing): Claude Code GitHub issues #36006 (CLI), #54322 (VS Code verbose toggle).

Thanks @gavinBurtonStoreFeeder — the VS Code data point (2.1.210, Windows, 138/138 empty with signature) matches exactly, and the renderer analysis is a useful confirmation that the clients render correctly for empty input.

On your open question about which layer drops the plaintext, the A/B in the original report resolves most of it: in a single desktop session on runtime 2.1.205, a Haiku 4.5 subagent's thinking blocks persist with plaintext through the same SDK/persistence pipeline that stores Fable 5 blocks empty. If the SDK/harness were stripping text at stream- or persist-time, Haiku's blocks would be empty too. So this is your candidate (a): the API returns signature-only thinking for omitted-default models (Fable 5 / Sonnet 5 / Opus 4.7+) unless the client requests thinking.display: "summarized" — which is exactly what showThinkingSummaries: true is documented to do, and what the desktop (and apparently the VS Code extension) never sends.

One caveat on the terminal-CLI workaround: per #31326 the terminal has the same empty-by-default behavior since v2.1.69; the docs say showThinkingSummaries: true restores summaries there. If you can test that on your account, the contrast (works on terminal vs. no-op on desktop/VS Code) would sharpen the fix scope for the maintainers.

Update: resolved by the Claude Desktop 1.21459.0 client update — summaries are arriving again.

Data from the same machine/account as the report (all UTC; CC runtime version constant throughout):

| Turn time | Desktop build | CC runtime | thinking text |
|---|---|---|---|
| 07-14 11:56–12:05 | 1.20186.9 | 2.1.209 | all empty |
| 07-15 ~01:00 | 1.21459.0 auto-installed | 2.1.209 | — |
| 07-15 04:37 onward | 1.21459.0 / .1 | 2.1.209 | all populated (≈150–3,600 chars, summarized-sized) |

Since the runtime is identical on both sides of the boundary, the change came with the Desktop app build (1.20186.9 → 1.21459.0), not the CC runtime — consistent with the host now enabling/requesting thinking.display: "summarized". The Desktop UI renders the summaries inline, including on Fable 5. showThinkingSummaries: true was set the whole time, so I can't tell whether the new build honors it or enables summaries by default.

@gavinBurtonStoreFeeder — worth checking whether a VS Code extension update past your 2.1.210 does the same there.

From my side the core symptom is resolved as of 1.21459.0. Leaving open in case the maintainers want to confirm intent/scope (and the cosmetic point stands: when text is absent, the panel still renders as expandable-but-empty). Feel free to close otherwise.

Follow-up: the fix is partial — Cowork (VM sandbox) sessions on the same Desktop build still receive empty thinking.

Same machine/account, Desktop 1.21459.1. The two desktop surfaces now diverge:

| Surface | How the runtime is launched | Runtime | thinking text |
|---|---|---|---|
| Code tab (local agent) | host-spawned claude --output-format stream-json … | 2.1.209 | summaries since 1.21459.0 ✅ |
| Cowork tab (VM sandbox) | in-VM claude --preload /home/claude/.claude/remote/spare.sock | 2.1.211 | still all empty ❌ |

Verified from inside the Cowork environment (2026-07-16, model claude-fable-5, CLI 2.1.211): every thinking block in the in-VM session transcript is thinking: "" + signature — the same shape as the original report.

Likely why it was missed: the Cowork environment has no user ~/.claude/settings.json — only a launcher-injected launcher-settings.json (hooks/permissions/skillOverrides; no thinking keys) — and the session is configured via the preload socket, not CLI flags. So whatever 1.21459.0 changed for local sessions (requesting thinking.display: "summarized") doesn't propagate through the Cowork VM/preload launcher path.

Note this also rules out runtime version as the variable: the in-VM CLI (2.1.211) is newer than my local one (2.1.209), where summaries now work.

Could the same enablement be applied to the Cowork launcher path (via the preload protocol or launcher-settings)?

Thanks for your response, @r99-creator

I am now on 2.1.215 of the VS code extension, and I can confirm that there are still no thinking blocks.

Using Opus 4.8 I've created this updated report, showing the logs with the transcript from that session itself. The tldr here is that no sonnet or opus logs have any kind of visible thinking tokens. Only a hauku sub-agent.

I'm leaning in the direction of this having been an intentional change by Anthropic.

Reproduction: showThinkingSummaries ignored — thinking blocks persist as "" on Opus 4.8

Re: anthropics/claude-code#77460
Date: 2026-07-20
Environment: Claude Code runtime 2.1.215, VS Code extension, model claude-opus-4-8 (1M context), first-party Anthropic API.

Update

The bug reproduces on claude-opus-4-8 as well (the issue names Opus 4.7+, Fable 5, Sonnet 5). Every assistant turn emits a thinking block whose thinking field is an empty string while carrying a full ~1KB signature. The reasoning block genuinely exists server-side (the signature proves it), but the human-readable summary text is never returned — so the transcript, and the desktop "Thought process" panel, get nothing.

Aggregate evidence (this machine's session logs)

Grep across ~/.claude/projects/c--projects-agents-sprt6-agent-workspace/**.jsonl:

| Thinking block state | Count | Files |
|---|---|---|
| "thinking":"" (empty) | 1516 | 24 |
| "thinking":"<text>" (populated) | 5 | 1 |

All 5 populated blocks are in a single log — a claude-haiku-4-5-20251001 subagent (claude-code-guide). No claude-opus-4-8 turn anywhere in the workspace has non-empty thinking text. That is the exact A/B split the issue reports: Haiku 4.5 = summaries present; omitted-default models (Opus/Fable/Sonnet 5) = empty.

---

Sample A — EMPTY thinking (claude-opus-4-8, main session)

From 610d78a2-cf24-41b4-82b8-54146c1801bc.jsonl (this very session). Note "thinking":"":

{
  "message": {
    "model": "claude-opus-4-8",
    "type": "message",
    "role": "assistant",
    "content": [
      {
        "type": "thinking",
        "thinking": "",
        "signature": "EvcGCokBCA8YAipA+C+7AGNlq/Awwo6S1lv+1+3H2M0fQS3Q ...[SIGNATURE MIDDLE REDACTED]... CQDtWtgidE37TwO568QK8PIYAQ=="
      }
    ],
    "stop_reason": "tool_use"
  },
  "effort": "xhigh",
  "version": "2.1.215"
}

A second turn in the same session (msg_011CdD9cVeKKPe325AqbfmGs) is identical: "thinking":"" with a different full signature. Both were produced at effort: "xhigh" — the reasoning ran; only the summary text is missing.

---

Sample B — POPULATED thinking (claude-haiku-4-5, subagent)

From 340c7073-3f43-44f1-b421-d140558e3b1e/subagents/agent-a101274b71c5ad761.jsonl. Same workspace, same day-to-day usage — the only difference is the model:

{
  "message": {
    "model": "claude-haiku-4-5-20251001",
    "type": "message",
    "role": "assistant",
    "content": [
      {
        "type": "thinking",
        "thinking": "This is a critical distinction. The user is asking whether a PreToolUse hook on the `Skill` tool will block:\n1. The MODEL's calls to the Skill tool (auto-invocation)\n2. The USER's explicit slash commands (user-typed `/skill-name`)\n\nThis is a very specific architectural question about how Claude Code's harness routes user commands vs. tool calls. Let me search the documentation carefully [...] ",
        "signature": "Ev4JCpMBCA8YAipAM4q6tULFXn2ukBgG+6d96bvMUvlL/ftR ...[SIGNATURE MIDDLE REDACTED]... bTinXfUVi8TbIs7gnGAE="
      }
    ]
  },
  "attributionAgent": "claude-code-guide",
  "version": "2.1.204"
}

Here thinking contains the real summary text.

---

Interpretation

• Not a "model isn't reasoning" problem. The empty blocks still carry a large signature, i.e. the encrypted/redacted reasoning block is present. What is absent is thinking.display: "summarized" — so the API returns the block with an empty summary (display: "omitted" default for Opus 4.7+/Fable 5/Sonnet 5).
• showThinkingSummaries: true is not being applied for omitted-default models — the runtime never upgrades the request to summarized, so the setting is a no-op. Haiku 4.5 (whose API default still emits summaries) is unaffected, which is why the one Haiku subagent log is the sole source of populated blocks.
• Impact: the desktop "Thought process" panel renders empty, and — more importantly for auditability — nothing readable about the model's reasoning is written to the session transcript.

How to reproduce / verify locally

1. Any Opus 4.7+/Fable 5 session with showThinkingSummaries: true in ~/.claude/settings.json.
2. Open the session .jsonl under ~/.claude/projects/<slug>/.
3. Grep for "type":"thinking","thinking":"" — every main-model assistant turn matches; the signature field is populated on each.
4. Contrast with any claude-haiku-4-5 subagent log, where thinking holds text.