fix(transform): preserve thinking-block integrity on Opus 4.7

Two related fixes for Anthropic's stricter thinking-block validation
that landed with Claude Opus 4.7. The same long-history session that
worked fine on Opus 4.6 was rejected by 4.7 with:
  'thinking or redacted_thinking blocks in the latest assistant
   message cannot be modified. These blocks must remain as they were
   in the original response.'

1. Preserve dropped user-message shells. Removing a user message
   collapses turn boundaries so @ai-sdk/anthropic merges adjacent
   assistants into one Anthropic assistant block, which invalidates
   the signed thinking history inside. Dropped user content is now
   replaced with a [truncated §N§] preview (keeping the shell) rather
   than removing the message.

2. Workaround @ai-sdk/anthropic's groupIntoBlocks producing
   interleaved [thinking, text, thinking, text, ...] layouts when
   multiple consecutive OpenCode assistants each carry signed
   reasoning. The new stripReasoningFromMergedAssistants pass strips
   reasoning from all but the first assistant in each consecutive run
   so the merged block keeps thinking at position 0. Upstream bug
   tracked for removal when @ai-sdk/anthropic is fixed (same class as
   Bedrock #13583/#13585/#13972).

Also:
- nudge-injection no longer targets thinking-bearing assistants; file
  parts are no longer treated as metadata-only content.
- Mock-provider now streams thinking_delta + signature_delta and
  advertises image/PDF modalities so the new e2e suite can exercise
  the live OpenCode + Anthropic-wire regressions end-to-end.

Author: ualtinok

packages/e2e-tests/src/mock-provider/server.ts

@@ -235,7 +235,13 @@ export class MockProvider {
 
                         // Emit each content block from the scripted `content` array.
                         content.forEach((block: unknown, index: number) => {
-                            const blk = block as { type?: string; text?: string };
+                            const blk = block as {
+                                type?: string;
+                                text?: string;
+                                thinking?: string;
+                                signature?: string;
+                                data?: string;
+                            };
                             const blockType = blk.type ?? "text";
 
                             if (blockType === "text") {
@@ -253,8 +259,59 @@ export class MockProvider {
                                     type: "content_block_stop",
                                     index,
                                 });
+                            } else if (blockType === "thinking") {
+                                // Real Anthropic streams thinking as:
+                                // 1. content_block_start { content_block: { type: "thinking", thinking: "" } }
+                                // 2. content_block_delta { delta: { type: "thinking_delta", thinking: "..." } }
+                                // 3. content_block_delta { delta: { type: "signature_delta", signature: "..." } }
+                                // 4. content_block_stop
+                                // @ai-sdk/anthropic reconstructs the reasoning part from these deltas.
+                                send("content_block_start", {
+                                    type: "content_block_start",
+                                    index,
+                                    content_block: { type: "thinking", thinking: "" },
+                                });
+                                if (blk.thinking) {
+                                    send("content_block_delta", {
+                                        type: "content_block_delta",
+                                        index,
+                                        delta: {
+                                            type: "thinking_delta",
+                                            thinking: blk.thinking,
+                                        },
+                                    });
+                                }
+                                if (blk.signature) {
+                                    send("content_block_delta", {
+                                        type: "content_block_delta",
+                                        index,
+                                        delta: {
+                                            type: "signature_delta",
+                                            signature: blk.signature,
+                                        },
+                                    });
+                                }
+                                send("content_block_stop", {
+                                    type: "content_block_stop",
+                                    index,
+                                });
+                            } else if (blockType === "redacted_thinking") {
+                                // Redacted thinking carries opaque `data` in the start event;
+                                // no deltas are emitted — the full payload arrives up front.
+                                send("content_block_start", {
+                                    type: "content_block_start",
+                                    index,
+                                    content_block: {
+                                        type: "redacted_thinking",
+                                        data: blk.data ?? "",
+                                    },
+                                });
+                                send("content_block_stop", {
+                                    type: "content_block_stop",
+                                    index,
+                                });
                             } else {
-                                // Pass through non-text blocks as-is (tool_use, etc.)
+                                // Pass through other non-text blocks as-is (tool_use, etc.)
                                 send("content_block_start", {
                                     type: "content_block_start",
                                     index,

packages/e2e-tests/src/opencode-runner/spawn.ts

@@ -112,6 +112,14 @@ function writeConfigs(
                         name: "Mock Sonnet",
                         cost: { input: 0, output: 0 },
                         limit: { context: opts.modelContextLimit ?? 200000, output: 8192 },
+                        // Advertise image + pdf input support so OpenCode does
+                        // not substitute inline file parts with "this model
+                        // does not support X input" text messages. Matches the
+                        // real Sonnet capabilities this mock is standing in for.
+                        modalities: {
+                            input: ["text", "image", "pdf"],
+                            output: ["text"],
+                        },
                         options: {},
                     },
                 },