refactor(core): upgrade ai-sdk v4 → v6 + Anthropic/openai-compatible reasoning round-trip + max-thinking budget audit

Migrates the LLM stack from [email protected] + @ai-sdk/[email protected] +
@ai-sdk/[email protected] to [email protected] + @ai-sdk/[email protected]
+ @ai-sdk/[email protected]. Full design in plan-v6-upgrade.md;
two rounds of Gemini code review captured in report.md.

Motivation: the recurring 'reasoning-signature without reasoning' error
on Claude Opus 4.7 was a v4 SDK artefact — @ai-sdk/[email protected] emitted
Anthropic signature_delta as a separate stream chunk that orphaned when
the model produced a signed-but-empty thinking block, and our chunk
store had no signature field so the round-trip back to Anthropic was
rejected on the next turn. In v6, signatures arrive inside
providerMetadata on the reasoning-end event, and the orphan-signature
class of bug is gone at the SDK level.

Core changes:
  • ThinkingChunk gains optional metadata?: Record<string, unknown>
    (the v6 providerMetadata blob). A non-undefined metadata 'seals'
    the chunk: subsequent reasoning-delta opens a new chunk rather
    than extending the sealed one.
  • AgentEvent gains { type: 'reasoning-end'; metadata? } (replaces
    the v4 reasoning-signature variant).
  • toModelMessages (replaces toCoreMessages):
      - returns ModelMessage[] (was CoreMessage[])
      - thinking → { type: 'reasoning', text, providerOptions: metadata }
      - tool-batch entries → { type: 'tool-call', input } (was 'args')
      - tool results → { output: { type: 'text', value } } ToolResultOutput
  • Claude OAuth uses createAnthropic({ authToken }) natively — no more
    custom-fetch x-api-key → Bearer swap.
  • rewriteBodyForOpus47 deleted — Opus 4.7 adaptive thinking is native
    via providerOptions.anthropic.thinking = { type: 'adaptive' }.
  • V1 middleware → V3 (specificationVersion: 'v3').
  • v4-era normalizeMessages openai-compatible middleware deleted; the
    v6 openai-compatible provider extracts reasoning_content natively
    from { type: 'reasoning' } content parts.
  • applyAnthropicStructuralNormalisations (mirrors opencode
    provider/transform.ts:53-148): drops empty text/reasoning parts,
    scrubs non-[a-zA-Z0-9_-] toolCallIds, splits [tool-call, non-tool]
    assistant turns (Anthropic rejects tool_use followed by text).
  • applyOpenAICompatibleReasoningNormalisation (mirrors opencode
    transform.ts:217-249): lifts reasoning text into
    providerOptions.openaiCompatible.reasoning_content (always, even
    empty). Solves DeepSeek 'The reasoning_content in the thinking
    mode must be passed back' — the v6 SDK skips emitting
    reasoning_content when text is empty (dist/index.mjs:245), but
    DeepSeek requires the field present once thinking was used.
  • Tools: tool({ inputSchema: jsonSchema(zodToJsonSchema(...)) })
    (was parameters: ZodSchema). AI SDK tools have no execute
    callback — the agent runs tools manually for permission prompts
    and shell-output streaming. New dep: zod-to-json-schema@^3.25.2.
  • fullStream event loop rewritten for v6 event shape: text-delta
    (text not textDelta), reasoning-start/delta/end, tool-input-*,
    tool-call (input not args), tool-result, tool-error (new), abort
    (new), start-step/finish-step, finish.

Max-thinking audit (matches opencode transform.ts:642-671 budgets):
  • Claude enabled-thinking max budget 16000 → 31999 (Anthropic ceiling)
  • Claude enabled-thinking high budget 10000 → 16000
  • maxOutputTokens 'budget + 8000' → fixed 32000 (matches opencode's
    OUTPUT_TOKEN_MAX; model self-allocates thinking vs response within)
  • Opus 4.7 adaptive thinking gains display: 'summarized' and sibling
    effort field (without these, thinking content is hidden by Anthropic
    and the model barely thinks).

Frontend mirrors:
  • types.ts — ThinkingChunk.metadata?, AgentEvent reasoning-end
  • tabs.svelte.ts — routes reasoning-end through applyChunkEvent
  • ChatMessage.svelte — hides empty thinking chunks; hides the entire
    assistant bubble when no chunk has renderable content

Gemini-review-driven fixes:
  • tool-error and abort stream events now surface as error chunks
    (were silently ignored)
  • toolCallId scrubbing pass (opencode transform.ts:96-122 parity)
  • Empty-reasoning-cull explicit test coverage for both Anthropic
    structural normalisation and DeepSeek path

Test counts (223 tests across 3 packages, all green):
  • tests/chunks/append.test.ts: 44 (was 38) — reasoning-end sealing,
    orphan walk-back, multi-block interleaving
  • tests/agent/agent.test.ts: 24 (was 5) — exhaustive v6 event
    mappings, structural normalisations, signature/reasoning_content
    round-trip, tool-error/abort branches, DeepSeek scenario, empty
    reasoning edge case
  • tests/llm/provider.test.ts: 9 (was 22) — dropped 13 obsolete v4
    middleware tests; new minimal tests confirm no middleware wrapping
    on default openai-compat path and that createAnthropic gets
    authToken vs apiKey correctly for OAuth vs api-key flows
  • tests/tools/registry.test.ts: 10 (was 4) — v6 tool() contract
    (inputSchema, no execute, JSON Schema for nested zod)
  • packages/api/tests/agent-manager.test.ts: 12 (was 7) — mock Agent
    emits v6 reasoning events; reasoning-end broadcast + ordering
  • packages/frontend/tests/chat-store.test.ts: 35 (was 32) —
    reasoning-end flow through Svelte $state store

typecheck clean (tsc --noEmit on core + api, svelte-check on frontend),
biome clean across 124 files.

1 files changed, 54 insertions, 12 deletions

diff --git a/packages/core/src/chunks/append.ts b/packages/core/src/chunks/append.ts
index 9c2a367..fe384bd 100644
--- a/packages/core/src/chunks/append.ts
+++ b/packages/core/src/chunks/append.ts
@@ -8,18 +8,31 @@
  *
  * Open/close rules — see plan-chunk-refactor.md for the full table.
  *
- *  | Chunk         | Opens on                                              | Coalesces                                                  |
- *  |---------------|-------------------------------------------------------|------------------------------------------------------------|
- *  | `text`        | first `text-delta` after a non-text chunk             | consecutive `text-delta` events append to `.text`          |
- *  | `thinking`    | first `reasoning-delta` after a non-thinking chunk    | consecutive `reasoning-delta` events append to `.text`     |
- *  | `tool-batch`  | first `tool-call` after a non-tool-batch chunk        | consecutive `tool-call` events push a new entry to `.calls`|
- *  | `error`       | every `error` event                                   | NEVER (always single-event)                                |
- *  | `system`      | every `notice`/`model-changed`/`config-reload`/...    | NEVER (two consecutive system events → two chunks)         |
+ *  | Chunk         | Opens on                                                        | Coalesces                                                  |
+ *  |---------------|-----------------------------------------------------------------|------------------------------------------------------------|
+ *  | `text`        | first `text-delta` after a non-text chunk                       | consecutive `text-delta` events append to `.text`          |
+ *  | `thinking`    | first `reasoning-delta` after a non-thinking chunk              | consecutive `reasoning-delta` events append to `.text`     |
+ *  |               | OR after the last thinking chunk was sealed by `reasoning-end`  | (only into the most recent UNSEALED thinking chunk)        |
+ *  | `tool-batch`  | first `tool-call` after a non-tool-batch chunk                  | consecutive `tool-call` events push a new entry to `.calls`|
+ *  | `error`       | every `error` event                                             | NEVER (always single-event)                                |
+ *  | `system`      | every `notice`/`model-changed`/`config-reload`/...              | NEVER (two consecutive system events → two chunks)         |
  *
  * Side-effect events (no new chunk):
- *  - `tool-result`  → finds the call by `id` across all `tool-batch` chunks (most-recent first)
- *                     and updates its `result` / `isError`.
- *  - `shell-output` → appends to the most recent entry of the most recent `tool-batch` chunk.
+ *  - `tool-result`   → finds the call by `id` across all `tool-batch`
+ *                       chunks (most-recent first) and updates its
+ *                       `result` / `isError`.
+ *  - `shell-output`  → appends to the most recent entry of the most
+ *                       recent `tool-batch` chunk.
+ *  - `reasoning-end` → attaches `metadata` (the AI SDK v6
+ *                       `providerMetadata` blob) to the most recent
+ *                       UNSEALED `thinking` chunk. The metadata is also
+ *                       the "sealed" marker — subsequent
+ *                       `reasoning-delta`s will open a new chunk rather
+ *                       than extending this one. Anthropic's signature
+ *                       lives inside this blob; round-tripping it on the
+ *                       next turn is mandatory for Anthropic to accept
+ *                       the conversation. Orphan `reasoning-end` events
+ *                       (no unsealed thinking chunk) are dropped.
  *
  * Ignored events:
  *  - `status`, `done`, `task-list-update`, `tab-created`, `message-queued`,
@@ -56,9 +69,14 @@ export function appendEventToChunks(chunks: Chunk[], event: AgentEvent): void {
 		}
 
 		case "reasoning-delta": {
-			// Open or extend the current thinking chunk.
+			// Open a new thinking chunk if the last chunk is not a thinking
+			// chunk OR if it's already sealed by metadata. Anthropic emits
+			// each thinking content block with its own metadata; a fresh
+			// reasoning-delta after a sealed thinking chunk is the start of
+			// a new block, not a continuation — extending the sealed chunk
+			// would corrupt the metadata/text mapping.
 			const last = chunks[chunks.length - 1];
-			if (last && last.type === "thinking") {
+			if (last && last.type === "thinking" && last.metadata === undefined) {
 				last.text += event.delta;
 			} else {
 				chunks.push({ type: "thinking", text: event.delta });
@@ -66,6 +84,30 @@ export function appendEventToChunks(chunks: Chunk[], event: AgentEvent): void {
 			return;
 		}
 
+		case "reasoning-end": {
+			// Attach `providerMetadata` to the most recent unsealed
+			// thinking chunk. Anthropic's signature lives inside this
+			// blob; without it on the next request, Anthropic rejects the
+			// thinking block. The walk-back is a defensive backstop —
+			// Anthropic's SSE delivers a content block's deltas strictly
+			// in order and `appendEventToChunks` runs synchronously per
+			// event, so the most recent thinking chunk is normally the
+			// last chunk in the array.
+			if (event.metadata === undefined) return;
+			for (let i = chunks.length - 1; i >= 0; i--) {
+				const c = chunks[i];
+				if (!c || c.type !== "thinking") continue;
+				if (c.metadata !== undefined) {
+					// Already sealed; the orphan metadata has no home.
+					return;
+				}
+				c.metadata = event.metadata;
+				return;
+			}
+			// No thinking chunk found at all — drop silently.
+			return;
+		}
+
 		case "tool-call": {
 			// Open or extend the current tool-batch chunk.
 			const last = chunks[chunks.length - 1];