fix: preserve thinking blocks when repairing tool pairs after compaction

[cdbattags]

Closes #261
Closes #212
Closes #226

Problem

OpenCode's automatic compaction can orphan a tool_use whose matching
tool_result is no longer in the immediately-following message.
repairToolPairs() (even with the adjacency fix from #250) mishandles two shapes:

1. An orphaned tool_use in an assistant turn that also holds a thinking
   block → the function drops the tool_use but keeps the thinking, a partial
   rewrite Anthropic rejects with "thinking ... blocks ... cannot be modified" (repairToolPairs() corrupts thinking blocks → Anthropic 400 on long conversations #261).
2. A duplicate/replayed tool_use id (first occurrence a valid pair, a later one
   orphaned) → the needsRepair gate only inspects first occurrences, so the
   orphan slips through as "tool_use ids ... without tool_result blocks
   immediately after" (Each tool_use block must have a corresponding tool_result block in the next message. #212/Sonnet rejects some /undo + /compact sessions that GPT still accepts #226).

Proven against the current release

Wire shape	Result	Error
thinking + orphaned tool_use, then assistant	drops tool_use, keeps thinking	#261
duplicate tool_use id (2nd orphaned)	orphan survives (needsRepair=false)	#212

Fix

Add OPENCODE_CLAUDE_AUTH_TOOL_REPAIR to select the strategy:

• placeholder (default): synthesize a paired placeholder tool_result for each
  orphaned tool_use. Assistant content[] is never mutated, so
  thinking / redacted_thinking blocks stay byte-identical — both repairToolPairs() corrupts thinking blocks → Anthropic 400 on long conversations #261 and
  Each tool_use block must have a corresponding tool_result block in the next message. #212 are closed.
• drop: harden the previous behavior — evaluate adjacency per-occurrence (fixes
  the duplicate-id gap), omit a whole thinking turn instead of partially
  rewriting it (repairToolPairs() corrupts thinking blocks → Anthropic 400 on long conversations #261), and iterate to a fixed point to reconcile cascades.

Emits a redacted repair_orphan_dropped / repair_orphan_synthesized debug event
(ids + indices only, no message content) under CLAUDE_AUTH_DEBUG.

Both shapes above now pass in both modes; new tests added, full suite green.

[griffinmartin]

@greptileai

[greptile-apps]

Greptile Summary

This PR adds a configurable OPENCODE_CLAUDE_AUTH_TOOL_REPAIR env-var to select between two strategies for fixing orphaned tool_use/tool_result adjacency after OpenCode auto-compaction: the new default placeholder mode synthesizes a paired error result without ever modifying assistant content (preserving thinking blocks byte-for-byte), and the hardened drop mode drops whole assistant thinking turns rather than partially rewriting them (avoiding Anthropic's thinking-preservation rejection) and evaluates adjacency per-occurrence to catch duplicate-id orphans.

• synthesizeMissingToolResults (placeholder): two-pass approach — pass 1 strips orphaned tool_result blocks from user turns; pass 2 walks pass1 and inserts synthetic placeholder tool_result entries adjacent to any uncovered tool_use, merging into an existing user turn or inserting a new one.
• repairToolPairs (drop): refactored into a dropPass helper iterated to a fixed point; each pass evaluates adjacency per-occurrence and drops whole thinking turns when any orphan is found, with cascade cleanup handled on subsequent passes.
• New exports (applyToolRepair, resolveToolRepairMode, synthesizeMissingToolResults, TOOL_RESULT_PLACEHOLDER) are thoroughly covered by new tests including duplicate-id, thinking-block, plain-string-content, and diagnostic-logging cases.

Confidence Score: 5/5

Safe to merge — both repair strategies are logically correct and the thinking-block invariant is upheld in all tested shapes.

The two-pass placeholder strategy correctly never touches assistant content, preserving thinking blocks byte-for-byte. The drop strategy's per-occurrence adjacency evaluation closes the duplicate-id gap, and the fixed-point iteration cleanly handles cascade removals within the proven message-length bound. All described failure shapes (thinking+orphan, duplicate ID, cascade) are covered by new tests, and the existing suite was updated to match the new API. No correctness gaps were found.

Files Needing Attention: No files require special attention.

Important Files Changed

Filename	Overview
src/transforms.ts	Core repair logic rewritten into two well-separated strategies; adjacency helpers are clear and correct; the fixed-point iteration in repairToolPairs is properly bounded; thinking-block invariant is upheld by both paths.
src/transforms.test.ts	Comprehensive new tests added for both modes, diagnostic logging, resolveToolRepairMode, and applyToolRepair dispatch; existing drop-mode test correctly updated to pass explicit mode argument.
README.md	Documents the new OPENCODE_CLAUDE_AUTH_TOOL_REPAIR variable with accurate description and default value.

Flowchart

%%{init: {'theme': 'neutral'}}%%
flowchart TD
    A[transformBody called] --> B{mode?}
    B -->|placeholder default| C[synthesizeMissingToolResults]
    B -->|drop| D[repairToolPairs]

    C --> C1[Pass 1: scan user turns\nremove orphaned tool_result blocks\nusing original message indices]
    C1 --> C2[Pass 2: walk pass1\nfor each assistant tool_use\ncheck adjacent user turn for result]
    C2 --> C3{result present\nin next turn?}
    C3 -->|yes| C4[no-op, continue]
    C3 -->|no, user turn follows| C5[merge placeholder\ninto existing user turn\nskip that turn i++]
    C3 -->|no, no user turn| C6[insert new user turn\nwith placeholder result]
    C5 --> C7[log repair_orphan_synthesized]
    C6 --> C7
    C4 --> C8[return output\nassistant content NEVER modified]
    C7 --> C8

    D --> D1[dropPass on current messages]
    D1 --> D2{message has\nthinking block AND\norphaned tool_use?}
    D2 -->|yes| D3[drop entire turn\nlog omittedThinkingTurns]
    D2 -->|no| D4[filter per-block\nadjacency check per-occurrence\ncatches duplicate IDs]
    D3 --> D5{changed?}
    D4 --> D5
    D5 -->|yes, iterate| D1
    D5 -->|no, fixed point| D6[return result]
    D5 -->|maxIterations exceeded| D7[log repair_drop_max_iterations\nreturn current]

Loading

_{Reviews (4): Last reviewed commit: "fix: handle string-content adjacent user..." | Re-trigger Greptile}

[cdbattags]

Addressed the two spots from the review summary in 46b5176:

• synthesizeMissingToolResults Pass 2 / string-content user turns — when the tool_use's adjacent turn is a plain-string user message, the synthetic result was emitted as a separate user message (two consecutive user turns). It now converts that turn to blocks so the tool_result leads it as a single user turn. Added a test + updated the transformBody placeholder test for the merged shape.
• dropPass thinking-turn omission with a valid+orphaned mix — omitting the whole turn also discards any valid tool_use it carries (its result is pruned on the next fixed-point pass). This is inherent to the repairToolPairs() corrupts thinking blocks → Anthropic 400 on long conversations #261 no-partial-rewrite rule in drop mode; documented the trade-off and added tests for both modes (drop leaves no orphans; the default placeholder preserves the turn and synthesizes only the missing result).