Bug: Missing `content[type="thinking"]` in Python Agent SDK agent-conversation JSONL (0.1.35+)

[RohanJ-oncp]

Summary

In agent-conversations/**/*.jsonl produced by the Claude Agent SDK for Python (claude-agent-sdk v0.1.35+), I often do not see assistant content blocks with type: "thinking" even when thinking is configured as enabled/adaptive with high effort or high budget_tokens.

Instead, intermediate reasoning appears in content[type="text"], and in some runs the missing thinking correlates with incorrect multi-step derived values.

Environment

• SDK: claude-agent-sdk v0.1.35+ (Python), including v0.1.52 (latest at time of reporting)
• Models tested:
  • claude-sonnet-4-5-20250929
  • claude-sonnet-4-6
• Thinking configs attempted:
  • thinking: { "type": "enabled", "budget_tokens": <high> }
  • thinking: { "type": "adaptive", "effort": "high" }

Expected

When thinking is enabled (or adaptive decides to think), agent-conversations/**/*.jsonl should consistently include assistant blocks like:

• content: [{ "type": "thinking", "thinking": "...", "signature": "..." }, ...]

Actual

type: "thinking" is missing in some agent conversation logs (especially subagent logs), while type: "text" increases or contains reasoning-like narration.

Version comparison

In my tests, behavior changes across claude-agent-sdk versions:

• With a newer claude-agent-sdk (>= 0.1.35), the produced agent conversation JSONL often omits assistant content blocks where type == "thinking".
• With an older claude-agent-sdk, assistant content blocks with type == "thinking" are present.
• Reproduced on v0.1.52 as well.

“Text replacing thinking” observation

When type: "thinking" blocks are missing, the number of assistant content blocks with type: "text" increases. These text blocks frequently contain visible, reasoning-like narration that appears to take the role that thinking blocks would normally serve, but this does not reliably translate into better agent performance (and in some runs correlates with less consistent/incorrect intermediate results).

Possible behavioral impact

In multiple cases, runs where thinking blocks were missing produced less consistent intermediate results compared to runs where thinking blocks were present.

Speed vs quality tradeoff observed

I also observed that runs without thinking blocks often complete faster, but that speedup appears to come with weaker agent performance/quality in intermediate reasoning outcomes.

Questions

1. Is it intentional that the Python SDK “agent conversation JSONL” omits type: "thinking" blocks from some runs/subagents even when thinking is enabled?
2. If intentional, can we get documentation and/or an option to include thinking blocks in transcripts for debugging (e.g. include_thinking_in_transcripts=true)?
3. If unintentional, can you point me to the code path that strips/omits thinking during transcript serialization/compaction?

Minimal reproduction (high level)

1. Use claude-agent-sdk v0.1.35+ with ClaudeAgentOptions(thinking=...) and tools/subagents.
2. Run an agent that produces agent-conversations/**/*.jsonl.
3. Inspect assistant message content blocks in the JSONL and check for content[].type == "thinking".

[Zerolzj]

Just like this ?

Traceback (most recent call last):
  File "/Users/zero/Documents/01_工作项目/code/workflow/Work4AI/.venv/lib/python3.14/site-packages/claude_agent_sdk/_internal/message_parser.py", line 110, in parse_message
    signature=block["signature"],
              ~~~~~^^^^^^^^^^^^^
KeyError: 'signature'

The above exception was the direct cause of the following exception:

[RohanJ-oncp]

@Zerolzj I am not facing an error, the issue is that my subagents have stopped thinking

[nanookclaw]

The KeyError: 'signature' in Zerolzj's trace points to a specific code path worth flagging here.

In message_parser.py, line 110:

signature=block["signature"],  # KeyError if field absent

The Anthropic API can return thinking blocks without a signature field in certain conditions (redacted thinking, streaming edge cases, or when thinking is present in older cached responses). The parser assumes the field is always present.

The fix is one line:

# Before
signature=block["signature"],

# After  
signature=block.get("signature", ""),

This matches the behavior of the Anthropic Python SDK's own ThinkingBlockParam parsing, which treats signature as optional in some contexts. The omission is what causes RohanJ's observation that subagent JSONL sometimes shows reasoning narration in type:text blocks instead of type:thinking blocks — if a thinking block parse fails, the parser silently continues and the content surfaces differently.

Happy to file a PR with the defensive .get() fix if this is the direction you'd like to go. It's a one-line change with a targeted test for a thinking block response that omits the signature field.