@intx/inference 0.2.2 → 0.3.0

package/dist/harness.js

@@ -14,9 +14,10 @@
 // handling, or event emission. They translate request/response shapes.
 import { type } from "arktype";
 import { getLogger } from "@intx/log";
+import { detectResponseKind, } from "@intx/types/content-type";
 import { parseSSE } from "./sse.js";
 import { injectCredentials } from "./auth.js";
-import { classifyHTTPError, classifyNetworkError, classifyAbortError, classifyStreamError, classifyTimeoutError, ProtocolMismatchError, } from "./errors.js";
+import { classifyHTTPError, classifyNetworkError, classifyAbortError, classifyStreamError, classifyTimeoutError, classifyProtocolMismatch, ProtocolMismatchError, } from "./errors.js";
 import { createDefaultRetryPolicy } from "./retry-policy.js";
 const logger = getLogger(["interchange", "inference", "harness"]);
 /**
@@ -128,6 +129,9 @@ async function* runSingleAttempt(opts) {
     // different keys.
     const citationsByIndex = new Map();
     const unindexedCitations = [];
+    // Prompt-level safety signals (no candidate index on the first
+    // capture). Appended to the finalized turn after indexed blocks.
+    const unindexedSafetyRatings = [];
     let usageSeen = null;
     const openToolCalls = new Map();
     // OpenAI uses index-based tracking before we have a real callId.
@@ -142,7 +146,7 @@ async function* runSingleAttempt(opts) {
     }
     let adapter;
     try {
-        adapter = deps.adapters.resolve(lastCycleSource);
+        adapter = deps.adapters.resolve(lastCycleSource, source.quirks);
     }
     catch (cause) {
         yield {
@@ -309,13 +313,55 @@ async function* runSingleAttempt(opts) {
             };
             return;
         }
+        // Captured as a const so the non-null narrowing from the guard above
+        // carries into the SSE branch of the event-source generator below (a
+        // bare `response.body` re-widens to nullable across the closure).
+        const responseBody = response.body;
+        let responseKind;
+        try {
+            responseKind = detectResponseKind(response.headers);
+        }
+        catch (cause) {
+            // A 2xx whose Content-Type is neither SSE nor JSON is a protocol
+            // violation, not a transient failure — surface it loudly rather than
+            // pushing unknown bytes through the SSE parser to yield an empty turn.
+            yield {
+                type: "inference.error",
+                seq: nextSeq(),
+                data: {
+                    error: classifyProtocolMismatch(cause instanceof Error ? cause.message : String(cause)),
+                    partial: snapshotPartial(partial),
+                },
+            };
+            return;
+        }
         // Arm the inactivity timer now that the SSE stream is open. Every
         // event we yield below resets it; sustained silence past
         // `inactivityTimeoutMs` aborts the controller and the loop's catch
-        // surfaces the timeout error.
-        armInactivity();
+        // surfaces the timeout error. A non-streaming JSON body has no
+        // inter-event silence to detect, so the timer stays disarmed there and
+        // the total-timeout controller alone bounds the buffered read.
+        if (responseKind === "sse") {
+            armInactivity();
+        }
+        // The event source: one branch per response kind, both feeding batches
+        // of raw adapter events into the shared accumulator below. SSE yields
+        // one batch per wire chunk; JSON buffers the whole body and yields a
+        // single batch.
+        const rawEventBatches = async function* () {
+            if (responseKind === "json") {
+                const body = await awaitWithSignal(response.text(), fetchSignal);
+                yield adapter.parseJSONResponse(body);
+                return;
+            }
+            for await (const sseData of parseSSE(responseBody)) {
+                // Reset inactivity timer — we just got something from the wire.
+                armInactivity();
+                yield adapter.parseResponse(sseData);
+            }
+        };
         try {
-            for await (const sseData of parseSSE(response.body)) {
+            for await (const rawEvents of rawEventBatches()) {
                 if (timeoutReason !== null) {
                     // The timeout aborted the stream; bubble up the right error
                     // shape rather than letting the abort masquerade as a
@@ -344,9 +390,6 @@ async function* runSingleAttempt(opts) {
                     };
                     return;
                 }
-                // Reset inactivity timer — we just got something from the wire.
-                armInactivity();
-                const rawEvents = adapter.parseResponse(sseData);
                 for (const raw of rawEvents) {
                     switch (raw.type) {
                         case "inference.text.delta": {
@@ -372,6 +415,7 @@ async function* runSingleAttempt(opts) {
                                 data: {
                                     token: raw.data.token,
                                     partial: snapshotPartial(partial),
+                                    index: idx,
                                 },
                             };
                             break;
@@ -432,24 +476,33 @@ async function* runSingleAttempt(opts) {
                                 data: {
                                     token: raw.data.token,
                                     partial: snapshotPartial(partial),
+                                    index: idx,
                                 },
                             };
                             break;
                         }
-                        case "inference.thinking.signature": {
-                            const idx = requireIndex(raw, "thinking.signature");
+                        case "inference.block.signature": {
+                            const idx = requireIndex(raw, "block.signature");
                             const existing = blockMap.get(idx);
                             if (existing === undefined) {
-                                throw new ProtocolMismatchError(`harness: thinking.signature at index ${String(idx)} has no preceding thinking block at that index`, raw);
+                                throw new ProtocolMismatchError(`harness: block.signature at index ${String(idx)} has no preceding block at that index`, raw);
                             }
-                            if (existing.kind !== "thinking") {
-                                throw new ProtocolMismatchError(`harness: thinking.signature at index ${String(idx)} targets an existing ${existing.kind} block, not a thinking block`, raw);
+                            // A signature authenticates the block whose part it rides on.
+                            // The signable kinds are the ones whose ContentBlock carries a
+                            // `signature` field; the others (redacted_thinking, refusal,
+                            // code_execution_result) have no place to hold one.
+                            if (existing.kind !== "thinking" &&
+                                existing.kind !== "text" &&
+                                existing.kind !== "tool_use" &&
+                                existing.kind !== "image" &&
+                                existing.kind !== "code_execution_request") {
+                                throw new ProtocolMismatchError(`harness: block.signature at index ${String(idx)} targets an existing ${existing.kind} block, which does not carry a signature`, raw);
                             }
                             existing.signature = raw.data.signature;
                             yield {
-                                type: "inference.thinking.signature",
+                                type: "inference.block.signature",
                                 seq: nextSeq(),
-                                data: { signature: raw.data.signature },
+                                data: { signature: raw.data.signature, index: idx },
                             };
                             break;
                         }
@@ -476,6 +529,16 @@ async function* runSingleAttempt(opts) {
                             };
                             break;
                         }
+                        case "inference.safety_rating": {
+                            const safetyRating = raw.data.safetyRating;
+                            unindexedSafetyRatings.push(safetyRating);
+                            yield {
+                                type: "inference.safety_rating",
+                                seq: nextSeq(),
+                                data: { safetyRating },
+                            };
+                            break;
+                        }
                         case "inference.thinking.redacted": {
                             const idx = requireIndex(raw, "thinking.redacted");
                             const existing = blockMap.get(idx);
@@ -536,7 +599,12 @@ async function* runSingleAttempt(opts) {
                             yield {
                                 type: "inference.tool_call.start",
                                 seq: nextSeq(),
-                                data: { callId, name, partial: snapshotPartial(partial) },
+                                data: {
+                                    callId,
+                                    name,
+                                    partial: snapshotPartial(partial),
+                                    index: toolIdx,
+                                },
                             };
                             break;
                         }
@@ -837,9 +905,19 @@ async function* runSingleAttempt(opts) {
         };
         for (const [idx, entry] of blockMap.entries()) {
             if (entry.kind === "text") {
-                if (entry.text.length > 0) {
-                    emit({ type: "text", text: entry.text }, idx);
+                // Emit even with empty text if a signature was captured, so a
+                // signature riding on an otherwise-empty text carrier still
+                // round-trips (mirrors the thinking-block rule below).
+                if (entry.text.length === 0 && entry.signature === undefined) {
+                    continue;
                 }
+                emit({
+                    type: "text",
+                    text: entry.text,
+                    ...(entry.signature !== undefined
+                        ? { signature: entry.signature }
+                        : {}),
+                }, idx);
                 continue;
             }
             if (entry.kind === "thinking") {
@@ -890,7 +968,12 @@ async function* runSingleAttempt(opts) {
                     // the tool call from the final turn.
                     throw new ProtocolMismatchError(`harness: tool_use marker at callId ${entry.callId} has no matching completed tool call`, entry);
                 }
-                emit(finalized, idx);
+                if (finalized.type !== "tool_call") {
+                    throw new ProtocolMismatchError(`harness: tool_use marker at callId ${entry.callId} resolved to a ${finalized.type} block, not a tool_call`, entry);
+                }
+                emit(entry.signature !== undefined
+                    ? { ...finalized, signature: entry.signature }
+                    : finalized, idx);
                 continue;
             }
             if (entry.kind === "image") {
@@ -900,7 +983,9 @@ async function* runSingleAttempt(opts) {
                 // atomic, not streamed), so the final-walk emits it
                 // verbatim. Citation interleave applies the same way as
                 // any other block kind.
-                emit(entry.image, idx);
+                emit(entry.signature !== undefined
+                    ? { ...entry.image, signature: entry.signature }
+                    : entry.image, idx);
                 continue;
             }
             if (entry.kind === "code_execution_request") {
@@ -910,7 +995,9 @@ async function* runSingleAttempt(opts) {
                 // current wire delivers all of it atomically on `start`;
                 // streaming providers would extend `request.code` via the
                 // delta handler before this walk runs.
-                emit(entry.request, idx);
+                emit(entry.signature !== undefined
+                    ? { ...entry.request, signature: entry.signature }
+                    : entry.request, idx);
                 continue;
             }
             if (entry.kind === "code_execution_result") {
@@ -931,6 +1018,7 @@ async function* runSingleAttempt(opts) {
             throw new ProtocolMismatchError(`harness: ${String(citationsByIndex.size)} citation index/indices have no matching emitted block in the final turn: ${orphanIndices.join(", ")}`, { orphanIndices });
         }
         contentBlocks.push(...unindexedCitations);
+        contentBlocks.push(...unindexedSafetyRatings);
         const finalTurn = {
             role: "assistant",
             content: contentBlocks,

package/dist/index.d.ts

@@ -13,7 +13,7 @@ export { createDefaultRetryPolicy } from "./retry-policy.js";
 export type { RetryPolicy, RetrySituation, RetryDecision, } from "@intx/types/runtime";
 export { uploadGoogleGenAIFile } from "./providers/google-genai-files.js";
 export type { UploadGoogleGenAIFileOpts, UploadGoogleGenAIFileFetch, UploadedGoogleGenAIFile, } from "./providers/google-genai-files.js";
-export { createInboundTurn } from "./turns.js";
+export { createInboundTurn, assertWellFormedToolSequence } from "./turns.js";
 export { createReactor } from "./reactor.js";
 export type { Reactor, ReactorConfig, ReactorEmittedEvent } from "./reactor.js";
 export { validateActions } from "./actions.js";

package/dist/index.js

@@ -7,7 +7,7 @@ export { classifyHTTPError, classifyNetworkError, classifyAbortError, classifySt
 export { transformMessages, createIDNormalizer } from "./transform.js";
 export { createDefaultRetryPolicy } from "./retry-policy.js";
 export { uploadGoogleGenAIFile } from "./providers/google-genai-files.js";
-export { createInboundTurn } from "./turns.js";
+export { createInboundTurn, assertWellFormedToolSequence } from "./turns.js";
 export { createReactor } from "./reactor.js";
 export { validateActions } from "./actions.js";
 export { createGateManager } from "./gates.js";

package/dist/providers/anthropic.d.ts

@@ -1,5 +1,7 @@
 import type { LastCycleSource } from "@intx/types/runtime";
 import type { ProviderAdapter } from "../adapter.js";
+export declare const ADAPTIVE_THINKING_MODELS: ReadonlySet<string>;
+export declare const ADAPTIVE_THINKING_EFFORT = "high";
 export type AnthropicRawEvent = {
     kind: "text_delta";
     token: string;
@@ -30,4 +32,6 @@ export type AnthropicRawEvent = {
 } | {
     kind: "skip";
 };
-export declare function createAnthropicAdapter(source: LastCycleSource): ProviderAdapter;
+export declare const AnthropicQuirks: import("arktype/internal/variants/object.ts").ObjectType<{}, {}>;
+export type AnthropicQuirks = typeof AnthropicQuirks.infer;
+export declare function createAnthropicAdapter(source: LastCycleSource, quirks?: unknown): ProviderAdapter;

package/dist/providers/anthropic.js

@@ -1,5 +1,5 @@
 import { type } from "arktype";
-import { CitationBlock as CitationBlockType } from "@intx/types/runtime";
+import { CitationBlock as CitationBlockType, formatSafetyRatingText, } from "@intx/types/runtime";
 import { CREDENTIAL_SENTINEL } from "../auth.js";
 import { ProtocolMismatchError } from "../errors.js";
 import { decodeToolName, encodeToolName, } from "../tool-name.js";
@@ -10,6 +10,27 @@ const ANTHROPIC_TOOL_NAME_LIMIT = {
     provider: "anthropic",
     maxLength: 128,
 };
+// Models that reject thinking:{type:"enabled",budget_tokens} and require
+// thinking:{type:"adaptive"} with output_config.effort. The discovery
+// plug-in's ADAPTIVE_THINKING_MODELS set must match this one; a guard test in
+// the anthropic discovery package pins the two equal so they cannot drift.
+export const ADAPTIVE_THINKING_MODELS = new Set([
+    "claude-sonnet-5",
+    "claude-opus-5",
+    "claude-fable-5",
+    "claude-opus-4-8",
+    "claude-opus-4-6",
+    "claude-opus-4-7",
+    "claude-sonnet-4-6",
+]);
+// The effort this adapter sends on the adaptive-thinking wire in production.
+// "high" is the Anthropic API default. The discovery capture rig deliberately
+// sends "max" instead: only "max" reliably elicits a thinking block to capture,
+// so the production default and the capture value are an intentional pair, not
+// drift. ADAPTIVE_THINKING_MODELS above must match across the two layers; the
+// effort values, by contrast, are meant to differ. A guard test in the
+// discovery package checks both effort values.
+export const ADAPTIVE_THINKING_EFFORT = "high";
 // ---------------------------------------------------------------------------
 // Request building
 // ---------------------------------------------------------------------------
@@ -47,10 +68,19 @@ function buildRequest(messages, model, options) {
         ];
     }
     if (options.thinking?.enabled) {
-        body["thinking"] = {
-            type: "enabled",
-            budget_tokens: options.thinking.budgetTokens ?? 1024,
-        };
+        // Adaptive models reject the classic budget_tokens shape with
+        // invalid_request_error and require thinking:{type:"adaptive"}
+        // plus output_config.effort.
+        if (ADAPTIVE_THINKING_MODELS.has(model)) {
+            body["thinking"] = { type: "adaptive" };
+            body["output_config"] = { effort: ADAPTIVE_THINKING_EFFORT };
+        }
+        else {
+            body["thinking"] = {
+                type: "enabled",
+                budget_tokens: options.thinking.budgetTokens ?? 1024,
+            };
+        }
     }
     if (options.tools !== undefined && options.tools.length > 0) {
         const tools = options.tools.map((t) => ({
@@ -94,7 +124,18 @@ function rejectUnsupportedResponseFormat(format) {
 }
 function toAnthropicMessage(msg, cacheLastBlock) {
     const role = msg.role === "assistant" ? "assistant" : "user";
-    const content = msg.content.map(toAnthropicBlock);
+    // safety_rating is Gemini output-only metadata. Rewrite as text so
+    // role alternation and the block reason survive Anthropic history
+    // without a native safety_rating input shape.
+    const content = msg.content.map((block) => {
+        if (block.type === "safety_rating") {
+            return toAnthropicBlock({
+                type: "text",
+                text: formatSafetyRatingText(block),
+            });
+        }
+        return toAnthropicBlock(block);
+    });
     if (cacheLastBlock) {
         const lastBlock = content[content.length - 1];
         if (lastBlock !== undefined) {
@@ -241,12 +282,21 @@ function toAnthropicBlock(block) {
         case "image":
             return { type: "image", source: toAnthropicMediaSource(block.source) };
         case "document":
-            return { type: "document", source: toAnthropicMediaSource(block.source) };
+            return {
+                type: "document",
+                source: toAnthropicMediaSource(block.source),
+                ...(block.title !== undefined ? { title: block.title } : {}),
+                ...(block.context !== undefined ? { context: block.context } : {}),
+            };
         case "audio":
         case "video":
             throw new Error(`Anthropic adapter does not yet handle ${block.type} content blocks.`);
         case "citation":
             throw new Error("Anthropic adapter does not yet emit citation content blocks.");
+        case "safety_rating":
+            // Rewritten to text in toAnthropicMessage before this switch.
+            throw new Error("Anthropic adapter: safety_rating blocks must be rewritten to " +
+                "text before toAnthropicBlock.");
         case "code_execution_request":
         case "code_execution_result":
             throw new Error(`Anthropic adapter does not yet emit ${block.type} content blocks.`);
@@ -405,6 +455,19 @@ const AnthropicSSEEvent = ContentBlockDelta.or(ContentBlockStart)
     .or(MessageStart)
     .or(MessageStop)
     .or(Ping);
+// Maps Anthropic's wire usage object onto the internal TokenUsage. Anthropic
+// never reports a distinct thinking-token count, so `thinking` is always 0.
+// Shared by the streaming `message_start` path and the non-streaming
+// `parseJSONResponse`, whose usage objects carry the same field names.
+function toInferenceUsage(usage) {
+    return {
+        input: usage.input_tokens ?? 0,
+        output: usage.output_tokens ?? 0,
+        cacheRead: usage.cache_read_input_tokens ?? 0,
+        cacheWrite: usage.cache_creation_input_tokens ?? 0,
+        thinking: 0,
+    };
+}
 function parseResponse(sseData, blockIndexToCallId, source) {
     // Same protocol-mismatch posture as the openai adapter: a JSON parse
     // failure or arktype rejection means the upstream emitted bytes that
@@ -460,7 +523,7 @@ function parseResponse(sseData, blockIndexToCallId, source) {
                 const signature = delta.signature ?? "";
                 return [
                     {
-                        type: "inference.thinking.signature",
+                        type: "inference.block.signature",
                         seq,
                         data: { signature, index },
                     },
@@ -603,18 +666,11 @@ function parseResponse(sseData, blockIndexToCallId, source) {
             const msgUsage = event.message?.usage;
             if (msgUsage === undefined)
                 return [];
-            const inferenceUsage = {
-                input: msgUsage.input_tokens ?? 0,
-                output: msgUsage.output_tokens ?? 0,
-                cacheRead: msgUsage.cache_read_input_tokens ?? 0,
-                cacheWrite: msgUsage.cache_creation_input_tokens ?? 0,
-                thinking: 0,
-            };
             return [
                 {
                     type: "inference.usage",
                     seq,
-                    data: { usage: inferenceUsage, source },
+                    data: { usage: toInferenceUsage(msgUsage), source },
                 },
             ];
         }
@@ -623,6 +679,186 @@ function parseResponse(sseData, blockIndexToCallId, source) {
             return [];
     }
 }
+// ---------------------------------------------------------------------------
+// Non-streaming response parsing
+//
+// The non-streaming Messages endpoint returns the same content blocks the
+// streaming protocol delivers incrementally, delivered whole in one JSON
+// body. `parseJSONResponse` re-expresses each complete block as the same
+// InferenceEvent vocabulary `parseResponse` emits, so a replayed
+// non-streaming capture feeds the harness accumulator identically to its
+// streaming sibling. Block types the streaming parser does not model
+// (server_tool_use, web_search_tool_result, code_execution_tool_result)
+// emit nothing here too; bringing those cells to parity across both paths is
+// owned by the strict-mode replay regression, not this parser.
+// ---------------------------------------------------------------------------
+const NonStreamingUsage = type({
+    "input_tokens?": "number",
+    "output_tokens?": "number",
+    "cache_read_input_tokens?": "number",
+    "cache_creation_input_tokens?": "number",
+});
+const NonStreamingMessage = type({
+    type: "'message'",
+    content: "unknown[]",
+    usage: NonStreamingUsage,
+});
+const BlockTag = type({ type: "string" });
+const NonStreamingTextBlock = type({
+    type: "'text'",
+    "text?": "string",
+    "citations?": AnthropicCitation.array(),
+});
+const NonStreamingToolUseBlock = type({
+    type: "'tool_use'",
+    "id?": "string",
+    "name?": "string",
+    "input?": "unknown",
+});
+const NonStreamingThinkingBlock = type({
+    type: "'thinking'",
+    "thinking?": "string",
+    "signature?": "string",
+});
+const NonStreamingRedactedThinkingBlock = type({
+    type: "'redacted_thinking'",
+    "data?": "string",
+});
+function parseJSONResponse(body, source) {
+    let parsed;
+    try {
+        parsed = JSON.parse(body);
+    }
+    catch (cause) {
+        const message = cause instanceof Error ? cause.message : String(cause);
+        throw new ProtocolMismatchError(`anthropic parseJSONResponse: malformed JSON response body: ${message}`, body);
+    }
+    const message = NonStreamingMessage(parsed);
+    if (message instanceof type.errors) {
+        throw new ProtocolMismatchError(`anthropic parseJSONResponse: response failed schema validation: ${message.summary}`, parsed);
+    }
+    // The seq field is a placeholder 0 — the harness assigns real sequence
+    // numbers, exactly as on the streaming path.
+    const seq = 0;
+    const events = [];
+    message.content.forEach((rawBlock, index) => {
+        const tagged = BlockTag(rawBlock);
+        if (tagged instanceof type.errors) {
+            throw new ProtocolMismatchError(`anthropic parseJSONResponse: content block ${String(index)} has no string type: ${tagged.summary}`, rawBlock);
+        }
+        switch (tagged.type) {
+            case "text": {
+                const block = NonStreamingTextBlock(rawBlock);
+                if (block instanceof type.errors) {
+                    throw new ProtocolMismatchError(`anthropic parseJSONResponse: text block ${String(index)} failed validation: ${block.summary}`, rawBlock);
+                }
+                events.push({
+                    type: "inference.text.delta",
+                    seq,
+                    data: { token: block.text ?? "", partial: EMPTY_PARTIAL, index },
+                });
+                // The streaming path emits one inference.citation per citations_delta
+                // keyed to the enclosing text block's index; the non-streaming shape
+                // carries those same citations inline on the block.
+                for (const citation of block.citations ?? []) {
+                    events.push({
+                        type: "inference.citation",
+                        seq,
+                        data: { citation: toCitationBlock(citation, index), index },
+                    });
+                }
+                break;
+            }
+            case "tool_use": {
+                const block = NonStreamingToolUseBlock(rawBlock);
+                if (block instanceof type.errors) {
+                    throw new ProtocolMismatchError(`anthropic parseJSONResponse: tool_use block ${String(index)} failed validation: ${block.summary}`, rawBlock);
+                }
+                // callId falls back to the block index exactly as the streaming
+                // content_block_start does, so a tool_use block with no id still
+                // correlates its start and args delta.
+                const callId = block.id ?? String(index);
+                events.push({
+                    type: "inference.tool_call.start",
+                    seq,
+                    data: {
+                        callId,
+                        name: decodeToolName(block.name ?? ""),
+                        partial: EMPTY_PARTIAL,
+                        index,
+                    },
+                });
+                events.push({
+                    type: "inference.tool_call.delta",
+                    seq,
+                    data: {
+                        callId,
+                        argumentFragment: JSON.stringify(block.input ?? {}),
+                        partial: EMPTY_PARTIAL,
+                        index,
+                    },
+                });
+                break;
+            }
+            case "thinking": {
+                const block = NonStreamingThinkingBlock(rawBlock);
+                if (block instanceof type.errors) {
+                    throw new ProtocolMismatchError(`anthropic parseJSONResponse: thinking block ${String(index)} failed validation: ${block.summary}`, rawBlock);
+                }
+                // Emit the thinking delta first so the harness has a thinking block
+                // at this index before the signature arrives; a signature with no
+                // preceding thinking entry is a protocol violation the harness
+                // rejects.
+                events.push({
+                    type: "inference.thinking.delta",
+                    seq,
+                    data: { token: block.thinking ?? "", partial: EMPTY_PARTIAL, index },
+                });
+                if (block.signature !== undefined) {
+                    events.push({
+                        type: "inference.block.signature",
+                        seq,
+                        data: { signature: block.signature, index },
+                    });
+                }
+                break;
+            }
+            case "redacted_thinking": {
+                const block = NonStreamingRedactedThinkingBlock(rawBlock);
+                if (block instanceof type.errors) {
+                    throw new ProtocolMismatchError(`anthropic parseJSONResponse: redacted_thinking block ${String(index)} failed validation: ${block.summary}`, rawBlock);
+                }
+                // The opaque `data` blob must echo back verbatim on follow-up turns;
+                // a missing `data` is a protocol violation, not a default-to-empty
+                // case, matching the streaming redacted_thinking handling.
+                if (block.data === undefined) {
+                    throw new ProtocolMismatchError(`anthropic parseJSONResponse: redacted_thinking block ${String(index)} missing required \`data\` field`, rawBlock);
+                }
+                events.push({
+                    type: "inference.thinking.redacted",
+                    seq,
+                    data: {
+                        redactedThinking: { type: "redacted_thinking", data: block.data },
+                        index,
+                    },
+                });
+                break;
+            }
+            default:
+                // server_tool_use, web_search_tool_result,
+                // code_execution_tool_result, and any future block type: the
+                // streaming parser emits nothing for these, so mirror that rather
+                // than diverge from a path with no passing reference yet.
+                break;
+        }
+    });
+    events.push({
+        type: "inference.usage",
+        seq,
+        data: { usage: toInferenceUsage(message.usage), source },
+    });
+    return events;
+}
 function extractRetryAfterMs(headers) {
     const raw = headers.get("retry-after");
     if (raw === null)
@@ -659,11 +895,22 @@ function extractPacingDelayMs(headers) {
     }
     return delays.length > 0 ? Math.max(...delays) : undefined;
 }
-export function createAnthropicAdapter(source) {
+// The anthropic adapter carries no per-source accommodations today, so its
+// quirks shape is empty. A quirks bag is deployment configuration crossing
+// into the system at this boundary; rejecting unknown keys makes a
+// misconfigured bag — for example an openai quirk pasted onto an anthropic
+// source — fail loudly here rather than run silently ignored.
+export const AnthropicQuirks = type({ "+": "reject" });
+export function createAnthropicAdapter(source, quirks) {
+    const parsedQuirks = AnthropicQuirks(quirks ?? {});
+    if (parsedQuirks instanceof type.errors) {
+        throw new Error(`anthropic adapter: invalid quirks: ${parsedQuirks.summary}`);
+    }
     const blockIndexToCallId = new Map();
     return {
         buildRequest,
         parseResponse: (sseData) => parseResponse(sseData, blockIndexToCallId, source),
+        parseJSONResponse: (body) => parseJSONResponse(body, source),
         extractRetryAfterMs,
         extractPacingDelayMs,
     };

package/dist/providers/google-genai.d.ts

@@ -1,3 +1,5 @@
 import type { LastCycleSource } from "@intx/types/runtime";
 import type { ProviderAdapter } from "../adapter.js";
-export declare function createGoogleGenAIAdapter(source: LastCycleSource): ProviderAdapter;
+export declare const GoogleGenAIQuirks: import("arktype/internal/variants/object.ts").ObjectType<{}, {}>;
+export type GoogleGenAIQuirks = typeof GoogleGenAIQuirks.infer;
+export declare function createGoogleGenAIAdapter(source: LastCycleSource, quirks?: unknown): ProviderAdapter;