@opencode/ai 2.0.21 → 2.0.23

package/README.md

@@ -27,6 +27,31 @@ Run `LLM.stream(...)` instead of `generate` when you want incremental `LLMEvent`
 `LLM.request(...)`. The event stream is provider-neutral — same shape across OpenAI Chat, OpenAI Responses,
 Anthropic Messages, Gemini, Bedrock Converse, and any OpenAI-compatible deployment.
 
+### Google Interactions
+
+`Google.configure({ apiKey }).interactions(modelID)` selects the Interactions API; `.model(modelID)` still selects
+GenerateContent. The package entrypoint is `@opencode/ai/providers/google/interactions`.
+
+```ts
+const model = Google.configure({ apiKey }).interactions("gemini-3.8-flash")
+const response = yield* LLM.generate({
+  model,
+  prompt: "Say hello.",
+  providerOptions: { thinkingLevel: "low", thinkingSummaries: "auto", store: true },
+})
+```
+
+Interactions supports text output, streamed function calls, native tool results, thought signatures, and multimodal
+input. Full-history replay is the default (`store: false`); implicit caching works without retained interactions.
+For server-side continuation, set `store: true` on the predecessor, read `interactionId` from the final event's
+`providerMetadata.google`, and pass `previousInteractionId` on the next request with **only new messages**. Repeat
+the system instructions and tool declarations on each request. Set `store: true` on each response you intend to
+continue from. The package does not automatically select or persist continuation IDs.
+
+Raw usage is preserved in `usage.providerMetadata.google`. `inputTokens` follows Google's top-level accounting;
+`contextTokens` uses its full `raw_prompt_token` count when supplied. These can differ substantially with server-side
+continuation. Explicit caches, hosted tools, and generated media are not supported by this initial protocol.
+
 The same configured facade names image, video, speech, and transcription models. `Image.generate` resolves the
 provider's image route from the model and returns `Media.Asset`s with lazily decoded bytes:
 
@@ -81,6 +106,41 @@ for await (const event of ai.llm.stream(ai.llm.request(input))) {
 await ai.dispose()
 ```
 
+## Venice AI
+
+`Venice` provides native Chat Completions with streaming tools and reasoning. `model` and `chat`
+select the same API; credentials default to `VENICE_API_KEY`.
+
+```ts
+import { LLM } from "@opencode/ai"
+import { Venice } from "@opencode/ai/providers"
+import { Effect } from "effect"
+
+const program = Effect.gen(function* () {
+  const response = yield* LLM.generate({
+    model: Venice.configure({ apiKey: process.env.VENICE_API_KEY }).chat("qwen3-6-27b"),
+    prompt: "Explain this design.",
+    providerOptions: {
+      reasoningEffort: "high",
+      veniceParameters: { includeVeniceSystemPrompt: false },
+    },
+  })
+  console.log(response.text)
+})
+```
+
+Effort lowers to `reasoning.effort`; `reasoning.enabled` and `reasoning.summary` are also available.
+Supported effort levels and toggles depend on the selected model. Omitted controls preserve its defaults.
+Venice's added system prompt is disabled by default, matching the previous OpenCode Venice SDK behavior.
+
+Replay complete `response.message` values to retain signed/encrypted reasoning and Gemini thought
+signatures, including per-tool signatures. Venice's encrypted scalar trailers are excluded from visible
+reasoning but retained in provider metadata for replay. Cache affinity uses `promptCacheKey`, and cache-write
+usage reads Venice's `cache_creation_input_tokens` field.
+
+The native package entrypoint is `@opencode/ai/providers/venice`. Image generation, embeddings, Responses, and
+client-side E2EE are not implemented by this provider.
+
 ## Experimental evaluation
 
 Evaluation models compare shared state with typed choice, score, and boolean questions. The API is
@@ -1223,7 +1283,7 @@ const gateway = CloudflareAIGateway.configure({
 }).model("workers-ai/@cf/meta/llama-3.1-8b-instruct")
 ```
 
-Included LLM providers: OpenAI, Anthropic, Google (Gemini), Google Vertex, Amazon Bedrock, Azure OpenAI, Baseten, Cerebras, Cloudflare AI Gateway, Cloudflare Workers AI, DeepInfra, DeepSeek, Fireworks, Groq, Mistral, OpenRouter, TogetherAI, and xAI. Z.ai currently exposes image generation. Generic Chat Completions, Responses, and Anthropic Messages-compatible entrypoints support custom endpoints.
+Included LLM providers: OpenAI, Anthropic, Google (Gemini), Google Vertex, Amazon Bedrock, Azure OpenAI, Baseten, Cerebras, Cohere, Cloudflare AI Gateway, Cloudflare Workers AI, DeepInfra, DeepSeek, Fireworks, Groq, Mistral, OpenRouter, TogetherAI, and xAI. Z.ai currently exposes image generation. Generic Chat Completions, Responses, and Anthropic Messages-compatible entrypoints support custom endpoints.
 
 Each named provider owns its module, endpoint, authentication, and route setup. Providers with the same wire format compose the shared protocol directly:
 

package/dist/cache-policy.js

@@ -36,9 +36,11 @@ const resolve = (policy) => {
 // prefix caching, Gemini's implicit + out-of-band CachedContent). Skip the
 // whole policy pass for these — emitting hints would be harmless but pointless.
 const RESPECTS_INLINE_HINTS = new Set([
+    "alibaba-chat",
     "alibaba-messages",
     "anthropic-messages",
     "anthropic-compatible-messages",
+    "bedrock-mantle-messages",
     "cloudflare-ai-gateway-messages",
     "google-vertex-messages",
     "meta-messages",
@@ -47,17 +49,19 @@ const RESPECTS_INLINE_HINTS = new Set([
     "zai-coding-messages",
     "bedrock-converse",
     "openrouter",
+    "digitalocean",
 ]);
 // OpenRouter upstreams other than Anthropic and Alibaba Qwen cache without breakpoints. Gemini uses only the last
 // breakpoint, so a conversation-tail breakpoint writes a new cache every step and costs more than none. Qwen ignores
 // breakpoints on tool definitions and caches tools with the system prompt.
+const QWEN = { system: true, messages: { tail: 1 } };
 const openRouterPolicy = (modelID) => {
     // `~anthropic/claude-sonnet-latest` style IDs are OpenRouter aliases for the latest model in a family.
     const id = modelID.replace(/^~/, "");
     if (id.startsWith("anthropic/"))
         return AUTO;
     if (id.startsWith("qwen/"))
-        return { system: true, messages: { tail: 1 } };
+        return QWEN;
     return NONE;
 };
 const makeHint = (ttlSeconds) => ttlSeconds !== undefined ? new CacheHint({ type: "ephemeral", ttlSeconds }) : new CacheHint({ type: "ephemeral" });
@@ -142,7 +146,11 @@ export const applyCachePolicy = (request) => {
         return request;
     const policy = request.model.route.id === "openrouter" && (request.cache === undefined || request.cache === "auto")
         ? openRouterPolicy(request.model.id)
-        : resolve(request.cache);
+        : request.model.route.id === "alibaba-chat" && (request.cache === undefined || request.cache === "auto")
+            ? request.model.id.toLowerCase().startsWith("qwen")
+                ? QWEN
+                : NONE
+            : resolve(request.cache);
     if (!policy.tools && !policy.system && !policy.messages)
         return request;
     const hint = makeHint(policy.ttlSeconds);

package/dist/llm.d.ts

@@ -206,6 +206,8 @@ export declare class GenerateObjectResponse<T> {
         readonly reason: {
             readonly normalized: "length" | "stop" | "tool-calls" | "content-filter" | "error" | "unknown";
             readonly raw?: string | undefined;
+            readonly category?: string | undefined;
+            readonly explanation?: string | undefined;
         };
         readonly index: number;
         readonly providerMetadata?: {
@@ -219,6 +221,8 @@ export declare class GenerateObjectResponse<T> {
         readonly reason: {
             readonly normalized: "length" | "stop" | "tool-calls" | "content-filter" | "error" | "unknown";
             readonly raw?: string | undefined;
+            readonly category?: string | undefined;
+            readonly explanation?: string | undefined;
         };
         readonly providerMetadata?: {
             readonly [x: string]: {

package/dist/promise.d.ts

@@ -233,6 +233,8 @@ export declare const make: (options?: Options) => {
             readonly reason: {
                 readonly normalized: "length" | "stop" | "tool-calls" | "content-filter" | "error" | "unknown";
                 readonly raw?: string | undefined;
+                readonly category?: string | undefined;
+                readonly explanation?: string | undefined;
             };
             readonly index: number;
             readonly providerMetadata?: {
@@ -246,6 +248,8 @@ export declare const make: (options?: Options) => {
             readonly reason: {
                 readonly normalized: "length" | "stop" | "tool-calls" | "content-filter" | "error" | "unknown";
                 readonly raw?: string | undefined;
+                readonly category?: string | undefined;
+                readonly explanation?: string | undefined;
             };
             readonly providerMetadata?: {
                 readonly [x: string]: {
@@ -720,6 +724,8 @@ export declare const ai: {
             readonly reason: {
                 readonly normalized: "length" | "stop" | "tool-calls" | "content-filter" | "error" | "unknown";
                 readonly raw?: string | undefined;
+                readonly category?: string | undefined;
+                readonly explanation?: string | undefined;
             };
             readonly index: number;
             readonly providerMetadata?: {
@@ -733,6 +739,8 @@ export declare const ai: {
             readonly reason: {
                 readonly normalized: "length" | "stop" | "tool-calls" | "content-filter" | "error" | "unknown";
                 readonly raw?: string | undefined;
+                readonly category?: string | undefined;
+                readonly explanation?: string | undefined;
             };
             readonly providerMetadata?: {
                 readonly [x: string]: {

package/dist/protocols/alibaba-chat.d.ts

@@ -152,10 +152,10 @@ export declare const protocol: Protocol<{
     readonly top_k?: number | undefined;
     readonly frequency_penalty?: number | undefined;
     readonly presence_penalty?: number | undefined;
+    readonly store?: boolean | undefined;
     readonly prompt_cache_key?: string | undefined;
     readonly parallel_tool_calls?: boolean | undefined;
     readonly reasoning_effort?: OpenResponsesOptions.ReasoningEffort | undefined;
-    readonly store?: boolean | undefined;
     readonly stream_options?: {
         readonly include_usage: boolean;
     } | undefined;
@@ -186,16 +186,18 @@ export declare const protocol: Protocol<{
     } | null | undefined;
     readonly usage?: {
         readonly [x: string]: unknown;
+        readonly cache_read_input_tokens?: number | null | undefined;
         readonly cached_tokens?: number | null | undefined;
+        readonly total_tokens?: number | null | undefined;
         readonly prompt_tokens?: number | null | undefined;
         readonly completion_tokens?: number | null | undefined;
-        readonly total_tokens?: number | null | undefined;
         readonly prompt_tokens_details?: {
             readonly [x: string]: unknown;
             readonly cached_tokens?: number | null | undefined;
             readonly cache_write_tokens?: number | null | undefined;
         } | null | undefined;
         readonly prompt_cache_hit_tokens?: number | null | undefined;
+        readonly cache_created_input_tokens?: number | null | undefined;
         readonly completion_tokens_details?: {
             readonly [x: string]: unknown;
             readonly reasoning_tokens?: number | null | undefined;
@@ -225,16 +227,18 @@ export declare const protocol: Protocol<{
         } | null | undefined;
         readonly usage?: {
             readonly [x: string]: unknown;
+            readonly cache_read_input_tokens?: number | null | undefined;
             readonly cached_tokens?: number | null | undefined;
+            readonly total_tokens?: number | null | undefined;
             readonly prompt_tokens?: number | null | undefined;
             readonly completion_tokens?: number | null | undefined;
-            readonly total_tokens?: number | null | undefined;
             readonly prompt_tokens_details?: {
                 readonly [x: string]: unknown;
                 readonly cached_tokens?: number | null | undefined;
                 readonly cache_write_tokens?: number | null | undefined;
             } | null | undefined;
             readonly prompt_cache_hit_tokens?: number | null | undefined;
+            readonly cache_created_input_tokens?: number | null | undefined;
             readonly completion_tokens_details?: {
                 readonly [x: string]: unknown;
                 readonly reasoning_tokens?: number | null | undefined;

package/dist/protocols/alibaba-chat.js

@@ -2,6 +2,7 @@ import { Effect, Schema } from "effect";
 import { Protocol } from "../route/protocol.js";
 import { OpenAIChat } from "./openai-chat.js";
 import { JsonObject, ProviderShared } from "./shared.js";
+import { cacheControl } from "./utils/cache.js";
 import { OpenResponsesOptions } from "./utils/open-responses-options.js";
 const Options = Schema.Struct({
     reasoningEffort: Schema.optional(OpenResponsesOptions.ReasoningEffort),
@@ -53,7 +54,7 @@ export const protocol = Protocol.make({
         from: Effect.fn("AlibabaChat.fromRequest")(function* (req) {
             const opts = yield* ProviderShared.validateWith(Schema.decodeUnknownEffect(Options))(req.providerOptions ?? {});
             return {
-                ...(yield* OpenAIChat.protocol.body.from(req)),
+                ...(yield* OpenAIChat.fromRequest(req, { cacheControl: cacheControl() })),
                 enable_thinking: opts.enableThinking,
                 // Alibaba also rejects an explicit budget that is not below `max_completion_tokens`.
                 thinking_budget: opts.thinkingBudget === undefined

package/dist/protocols/alibaba-responses.d.ts

@@ -48,6 +48,15 @@ export declare const protocol: Protocol<{
         readonly error?: unknown;
         readonly arguments?: string | undefined;
         readonly server_label?: string | undefined;
+    } | {
+        readonly type: "configuration_update";
+        readonly reasoning: {
+            readonly effort: OpenResponsesOptions.ReasoningEffort;
+        };
+    } | {
+        readonly [x: string]: unknown;
+        readonly type: string;
+        readonly id: string;
     } | {
         readonly type: "reasoning";
         readonly summary: readonly {
@@ -124,12 +133,6 @@ export declare const protocol: Protocol<{
             readonly type: "input_video";
             readonly video_url: string;
         })[];
-    } | {
-        readonly [x: string]: unknown;
-        readonly id: string;
-        readonly type: "web_extractor_call";
-        readonly urls?: readonly string[] | undefined;
-        readonly goal?: string | undefined;
     })[];
     readonly model: string;
     readonly stream: true;
@@ -142,6 +145,9 @@ export declare const protocol: Protocol<{
         readonly effort?: OpenResponsesOptions.ReasoningEffort | undefined;
     } | undefined;
     readonly tools?: readonly ({
+        readonly [x: string]: unknown;
+        readonly type: string;
+    } | {
         readonly type: "function";
         readonly description: string;
         readonly name: string;
@@ -149,8 +155,6 @@ export declare const protocol: Protocol<{
             readonly [x: string]: unknown;
         };
         readonly strict?: boolean | undefined;
-    } | {
-        readonly type: "web_search" | "code_interpreter" | "web_extractor";
     })[] | undefined;
     readonly text?: {
         readonly verbosity?: OpenResponsesOptions.TextVerbosity | undefined;
@@ -171,9 +175,10 @@ export declare const protocol: Protocol<{
     readonly top_p?: number | undefined;
     readonly frequency_penalty?: number | undefined;
     readonly presence_penalty?: number | undefined;
+    readonly store?: boolean | undefined;
+    readonly max_output_tokens?: number | undefined;
     readonly prompt_cache_key?: string | undefined;
     readonly parallel_tool_calls?: boolean | undefined;
-    readonly store?: boolean | undefined;
     readonly include?: readonly OpenResponsesOptions.ResponseIncludable[] | undefined;
     readonly truncation?: "auto" | "disabled" | undefined;
     readonly stream_options?: {
@@ -181,7 +186,6 @@ export declare const protocol: Protocol<{
     } | undefined;
     readonly safety_identifier?: string | undefined;
     readonly top_logprobs?: number | undefined;
-    readonly max_output_tokens?: number | undefined;
     readonly max_tool_calls?: number | undefined;
     readonly previous_response_id?: string | undefined;
     readonly conversation?: string | undefined;
@@ -204,8 +208,8 @@ export declare const protocol: Protocol<{
             readonly name?: string | undefined;
             readonly namespace?: string | undefined;
             readonly arguments?: string | undefined;
-            readonly encrypted_content?: string | null | undefined;
             readonly call_id?: string | undefined;
+            readonly encrypted_content?: string | null | undefined;
         }[] | undefined;
         readonly error?: unknown;
         readonly usage?: {
@@ -232,8 +236,8 @@ export declare const protocol: Protocol<{
         readonly name?: string | undefined;
         readonly namespace?: string | undefined;
         readonly arguments?: string | undefined;
-        readonly encrypted_content?: string | null | undefined;
         readonly call_id?: string | undefined;
+        readonly encrypted_content?: string | null | undefined;
     } | null | undefined;
     readonly delta?: string | undefined;
     readonly arguments?: string | undefined;

package/dist/protocols/alibaba-responses.js

@@ -1,7 +1,7 @@
 import { Effect, Schema } from "effect";
 import { Protocol } from "../route/protocol.js";
 import { OpenResponses } from "./open-responses.js";
-import { JsonObject, optionalArray, ProviderShared } from "./shared.js";
+import { JsonObject, ProviderShared } from "./shared.js";
 import { OpenResponsesOptions } from "./utils/open-responses-options.js";
 import { ResponsesHostedTools } from "./utils/responses-hosted-tools.js";
 const Options = Schema.Struct({
@@ -20,8 +20,6 @@ const WebExtractorItem = Schema.StructWithRest(Schema.Struct({
 }), [JsonObject]);
 const Body = Schema.Struct({
     ...OpenResponses.coreFields,
-    input: Schema.Array(Schema.Union([OpenResponses.InputItem, WebExtractorItem])),
-    tools: optionalArray(Schema.Union([OpenResponses.Tool, NativeTool])),
     enable_thinking: Options.fields.enableThinking,
     previous_response_id: Options.fields.previousResponseId,
     conversation: Options.fields.conversation,
@@ -45,7 +43,7 @@ export const protocol = Protocol.make({
             const opts = yield* ProviderShared.validateWith(Schema.decodeUnknownEffect(Options))(req.providerOptions ?? {});
             const body = yield* OpenResponses.fromRequestWithAdapter(req, adapter);
             const choice = body.tool_choice;
-            return yield* ProviderShared.validateWith(Schema.decodeUnknownEffect(Body))({
+            return {
                 ...body,
                 enable_thinking: opts.enableThinking,
                 previous_response_id: opts.previousResponseId,
@@ -54,7 +52,7 @@ export const protocol = Protocol.make({
                 tool_choice: typeof choice === "object" && choice.type === "function"
                     ? { type: "allowed_tools", mode: "required", tools: [choice] }
                     : choice,
-            });
+            };
         }),
     },
     stream: {

package/dist/protocols/anthropic-messages.js

@@ -359,6 +359,7 @@ const AnthropicStreamDelta = Schema.Struct({
     signature: Schema.optional(Schema.String),
     stop_reason: optionalNull(Schema.String),
     stop_sequence: optionalNull(Schema.String),
+    stop_details: optionalNull(Schema.Struct({ category: optionalNull(Schema.String), explanation: optionalNull(Schema.String) })),
 });
 const decodeAnthropicStreamDelta = Schema.decodeUnknownOption(AnthropicStreamDelta);
 const AnthropicEvent = Schema.Struct({
@@ -461,7 +462,7 @@ const serverToolResultType = (name) => {
         return "web_fetch_tool_result";
     return undefined;
 };
-const lowerServerToolResult = Effect.fn("AnthropicMessages.lowerServerToolResult")(function* (part, providerMetadataKey) {
+const lowerServerToolResult = Effect.fnUntraced(function* (part, providerMetadataKey) {
     const wireType = serverToolResultType(part.name);
     if (!wireType)
         return yield* invalid(`Anthropic Messages does not know how to round-trip server tool result for ${part.name}`);
@@ -537,7 +538,7 @@ const citationsFromMetadata = (metadata) => {
     return undefined;
 };
 const isHttpUrl = (value) => /^https?:\/\//i.test(value.trim());
-const lowerMedia = Effect.fn("AnthropicMessages.lowerMedia")(function* (part, breakpoints) {
+const lowerMedia = Effect.fnUntraced(function* (part, breakpoints) {
     const mime = part.media.mediaType.toLowerCase();
     const cacheControlValue = breakpoints ? cacheControl(breakpoints, part.cache) : undefined;
     const fileId = fileIdFromMetadata(part.metadata);
@@ -674,37 +675,17 @@ const requireThinkingSignature = (request) => {
         return false;
     return true;
 };
-// Mid-conversation system messages became available with Opus 4.8 and version
-// 5 of the other supported Claude families. Treat later family versions as
-// compatible without assuming that every Anthropic Messages model is Claude.
+// Opus 4.8 and every Claude 5 model accept mid-conversation system messages; later versions inherit support.
 const supportsNativeSystemUpdates = (request) => {
-    const match = /(?:^|[./])claude-(fable|haiku|mythos|opus|sonnet)-(\d+)(?:[.-](\d+))?/.exec(String(request.model.id).toLowerCase());
-    if (!match)
-        return false;
-    const major = Number(match[2]);
-    if (match[1] !== "opus")
-        return major >= 5;
-    if (major !== 4)
-        return major >= 5;
-    return match[3] !== undefined && match[3].length <= 2 && Number(match[3]) >= 8;
-};
-const endsInServerToolUse = (message) => {
-    const last = message.content.at(-1);
-    return message.role === "assistant" && last?.type === "tool-call" && last.providerExecuted === true;
-};
-const canUseNativeSystemUpdate = (request, index) => {
-    const previous = request.messages[index - 1];
-    const next = request.messages[index + 1];
-    // Vertex currently rejects/404s for a system message after local tool results,
-    // so fold it into the user tool-result turn across continuations and history.
-    if (request.model.route.id === "google-vertex-messages" && previous?.role === "tool")
+    const version = claudeVersion(String(request.model.id));
+    if (version === undefined)
         return false;
-    return (previous !== undefined &&
-        previous.role !== "system" &&
-        (previous.role === "user" || previous.role === "tool" || endsInServerToolUse(previous)) &&
-        next?.role !== "system" &&
-        (next === undefined || next.role === "assistant"));
+    if (version.family === "opus" && version.major === 4)
+        return version.minor >= 8;
+    return version.major >= 5;
 };
+// Native system messages must follow a user turn (tool results count) or a paused server-tool turn.
+const acceptsNativeSystemAfter = (message) => message?.role === "user" || (message?.role === "assistant" && message.content.at(-1)?.type === "server_tool_use");
 const splitsLocalToolResults = (messages, index) => {
     const pending = new Set();
     for (const message of messages.slice(0, index)) {
@@ -717,7 +698,7 @@ const splitsLocalToolResults = (messages, index) => {
     }
     return pending.size > 0;
 };
-const lowerNativeSystemUpdate = Effect.fn("AnthropicMessages.lowerNativeSystemUpdate")(function* (message, breakpoints) {
+const lowerNativeSystemUpdate = Effect.fnUntraced(function* (message, breakpoints) {
     const content = yield* ProviderShared.systemUpdateText("Anthropic Messages", message);
     return {
         role: "system",
@@ -728,9 +709,33 @@ const lowerNativeSystemUpdate = Effect.fn("AnthropicMessages.lowerNativeSystemUp
         })),
     };
 });
-const lowerMessages = Effect.fn("AnthropicMessages.lowerMessages")(function* (request, breakpoints) {
+const lowerWrappedSystemUpdate = Effect.fnUntraced(function* (message, breakpoints) {
+    const part = yield* ProviderShared.wrappedSystemUpdate("Anthropic Messages", message);
+    return { type: "text", text: part.text, cache_control: cacheControl(breakpoints, part.cache) };
+});
+const appendToUserTurn = (messages, block) => {
+    const last = messages.at(-1);
+    if (last?.role === "user")
+        messages[messages.length - 1] = { role: "user", content: [...last.content, block] };
+    else
+        messages.push({ role: "user", content: [block] });
+};
+const lowerMessages = Effect.fnUntraced(function* (request, breakpoints) {
     const messages = [];
     const providerMetadataKey = request.model.route.providerMetadataKey ?? String(request.model.provider);
+    // Text updates stay where they are unless a user turn follows them; then they move after the latest
+    // user turn, the nearest spot where Anthropic accepts a native system message.
+    const holdUpdates = supportsNativeSystemUpdates(request);
+    const held = [];
+    const releaseHeld = Effect.fnUntraced(function* () {
+        const native = acceptsNativeSystemAfter(messages.findLast((message) => message.role !== "system"));
+        for (const update of held.splice(0)) {
+            if (native)
+                messages.push(yield* lowerNativeSystemUpdate(update, breakpoints));
+            else
+                appendToUserTurn(messages, yield* lowerWrappedSystemUpdate(update, breakpoints));
+        }
+    });
     for (const [index, message] of request.messages.entries()) {
         if (message.role === "system") {
             const update = effortUpdate(message);
@@ -741,17 +746,10 @@ const lowerMessages = Effect.fn("AnthropicMessages.lowerMessages")(function* (re
             }
             if (splitsLocalToolResults(request.messages, index))
                 return yield* invalid("Anthropic Messages system updates cannot split a local tool call from its tool result");
-            if (supportsNativeSystemUpdates(request) && canUseNativeSystemUpdate(request, index)) {
-                messages.push(yield* lowerNativeSystemUpdate(message, breakpoints));
-                continue;
-            }
-            const part = yield* ProviderShared.wrappedSystemUpdate("Anthropic Messages", message);
-            const block = { type: "text", text: part.text, cache_control: cacheControl(breakpoints, part.cache) };
-            const previous = messages.at(-1);
-            if (previous?.role === "user")
-                messages[messages.length - 1] = { role: "user", content: [...previous.content, block] };
+            if (holdUpdates)
+                held.push(message);
             else
-                messages.push({ role: "user", content: [block] });
+                appendToUserTurn(messages, yield* lowerWrappedSystemUpdate(message, breakpoints));
             continue;
         }
         if (message.role === "user") {
@@ -827,8 +825,10 @@ const lowerMessages = Effect.fn("AnthropicMessages.lowerMessages")(function* (re
                 }
                 return yield* invalid(`Anthropic Messages assistant messages only support text, reasoning, and tool-call content for now`);
             }
-            if (content.length > 0)
-                messages.push({ role: "assistant", content });
+            if (content.length === 0)
+                continue;
+            yield* releaseHeld();
+            messages.push({ role: "assistant", content });
             continue;
         }
         const content = [];
@@ -849,8 +849,13 @@ const lowerMessages = Effect.fn("AnthropicMessages.lowerMessages")(function* (re
         else
             messages.push({ role: "user", content });
     }
+    yield* releaseHeld();
     return messages;
 });
+// TODO: Move per-model capability heuristics (`supportsEffortUpdates`, `supportsNativeSystemUpdates`,
+// `supportsThinkingBlockBinding`) into explicit model/provider `compatibility` metadata so the protocol
+// only reads `request.model.compatibility`.
+// Per-turn effort started with Claude Opus 5 and every Claude 5.1 model; later versions of any family inherit it.
 const supportsEffortUpdates = (model) => {
     const override = model.compatibility?.supportsEffortUpdates;
     if (override !== undefined)
@@ -858,10 +863,8 @@ const supportsEffortUpdates = (model) => {
     const version = claudeVersion(model.id);
     if (version === undefined)
         return false;
-    if (version.family === "opus")
-        return version.major >= 5;
-    if (version.family !== "fable" && version.family !== "mythos")
-        return false;
+    if (version.family === "opus" && version.major >= 5)
+        return true;
     return version.major > 5 || (version.major === 5 && version.minor >= 1);
 };
 const applyThinkingBindingDefault = (model, thinking) => {
@@ -1134,7 +1137,7 @@ const onContentBlockStart = (state, event) => {
     const events = [];
     return [{ ...state, lifecycle: Lifecycle.stepStart(state.lifecycle, events) }, [...events, result]];
 };
-const onContentBlockDelta = Effect.fn("AnthropicMessages.onContentBlockDelta")(function* (state, event) {
+const onContentBlockDelta = Effect.fnUntraced(function* (state, event) {
     const delta = event.delta;
     if (delta.type === "compaction_delta") {
         if (event.index === undefined || !(event.index in state.compactions) || delta.content === undefined)
@@ -1192,7 +1195,7 @@ const onContentBlockDelta = Effect.fn("AnthropicMessages.onContentBlockDelta")(f
     }
     return [state, NO_EVENTS];
 });
-const onContentBlockStop = Effect.fn("AnthropicMessages.onContentBlockStop")(function* (state, event) {
+const onContentBlockStop = Effect.fnUntraced(function* (state, event) {
     if (event.index === undefined)
         return [state, NO_EVENTS];
     if (event.index in state.compactions) {
@@ -1227,10 +1230,14 @@ const onMessageDelta = (state, event) => {
         const finishMetadata = stopSequence === null || stopSequence === undefined
             ? state.pendingFinish?.providerMetadata
             : providerMetadata(state.providerMetadataKey, { stopSequence });
+        const category = event.delta?.stop_details?.category;
+        const explanation = event.delta?.stop_details?.explanation;
         return {
             reason: {
                 normalized: mapFinishReason(stopReason),
                 raw: stopReason,
+                ...(category ? { category } : {}),
+                ...(explanation ? { explanation } : {}),
             },
             providerMetadata: finishMetadata,
         };
@@ -1244,7 +1251,7 @@ const onMessageDelta = (state, event) => {
         NO_EVENTS,
     ];
 };
-const onMessageStop = Effect.fn("AnthropicMessages.onMessageStop")(function* (state) {
+const onMessageStop = Effect.fnUntraced(function* (state) {
     if (Object.keys(state.compactions).length)
         return yield* ProviderShared.eventError(ADAPTER, "Response ended with an incomplete compaction block");
     const result = yield* ToolStream.finishAll(ADAPTER, state.tools);