@opencode/ai 2.0.19 → 2.0.21

package/dist/cache-policy.js

@@ -36,12 +36,30 @@ 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-messages",
     "anthropic-messages",
     "anthropic-compatible-messages",
+    "cloudflare-ai-gateway-messages",
     "google-vertex-messages",
+    "meta-messages",
+    "minimax-messages",
+    "moonshot-messages",
+    "zai-coding-messages",
     "bedrock-converse",
     "openrouter",
 ]);
+// 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 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 NONE;
+};
 const makeHint = (ttlSeconds) => ttlSeconds !== undefined ? new CacheHint({ type: "ephemeral", ttlSeconds }) : new CacheHint({ type: "ephemeral" });
 const markLastTool = (tools, hint, budget) => {
     const target = tools.at(-1);
@@ -122,9 +140,9 @@ const countHints = (request) => countToolHints(request.tools) +
 export const applyCachePolicy = (request) => {
     if (!RESPECTS_INLINE_HINTS.has(request.model.route.id))
         return request;
-    if (request.model.route.id === "openrouter" && (request.cache === undefined || request.cache === "auto"))
-        return request;
-    const policy = resolve(request.cache);
+    const policy = request.model.route.id === "openrouter" && (request.cache === undefined || request.cache === "auto")
+        ? openRouterPolicy(request.model.id)
+        : resolve(request.cache);
     if (!policy.tools && !policy.system && !policy.messages)
         return request;
     const hint = makeHint(policy.ttlSeconds);

package/dist/llm.d.ts

@@ -184,8 +184,8 @@ export declare class GenerateObjectResponse<T> {
     } | {
         readonly id: string;
         readonly type: "tool-error";
-        readonly name: string;
         readonly message: string;
+        readonly name: string;
         readonly error?: unknown;
         readonly providerMetadata?: {
             readonly [x: string]: {

package/dist/promise.d.ts

@@ -211,8 +211,8 @@ export declare const make: (options?: Options) => {
         } | {
             readonly id: string;
             readonly type: "tool-error";
-            readonly name: string;
             readonly message: string;
+            readonly name: string;
             readonly error?: unknown;
             readonly providerMetadata?: {
                 readonly [x: string]: {
@@ -698,8 +698,8 @@ export declare const ai: {
         } | {
             readonly id: string;
             readonly type: "tool-error";
-            readonly name: string;
             readonly message: string;
+            readonly name: string;
             readonly error?: unknown;
             readonly providerMetadata?: {
                 readonly [x: string]: {

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

@@ -80,15 +80,18 @@ export declare const protocol: Protocol<{
         })[];
     } | {
         readonly [x: string]: unknown;
-        readonly content: string | null;
+        readonly content: string | readonly {
+            readonly type: "text";
+            readonly text: string;
+            readonly cache_control?: {
+                readonly type: "ephemeral";
+                readonly ttl?: string | undefined;
+            } | undefined;
+        }[] | null;
         readonly role: "assistant";
         readonly reasoning?: string | undefined;
         readonly reasoning_content?: string | undefined;
         readonly reasoning_text?: string | undefined;
-        readonly cache_control?: {
-            readonly type: "ephemeral";
-            readonly ttl?: string | undefined;
-        } | undefined;
         readonly tool_calls?: readonly {
             readonly function: {
                 readonly name: string;
@@ -104,13 +107,16 @@ export declare const protocol: Protocol<{
         }[] | undefined;
         readonly reasoning_details?: unknown;
     } | {
-        readonly content: string;
         readonly role: "tool";
         readonly tool_call_id: string;
-        readonly cache_control?: {
-            readonly type: "ephemeral";
-            readonly ttl?: string | undefined;
-        } | undefined;
+        readonly content: string | readonly {
+            readonly type: "text";
+            readonly text: string;
+            readonly cache_control?: {
+                readonly type: "ephemeral";
+                readonly ttl?: string | undefined;
+            } | undefined;
+        }[];
     })[];
     readonly stream: true;
     readonly max_completion_tokens?: number | undefined;

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

@@ -77,8 +77,8 @@ export declare const protocol: Protocol<{
         } | {
             readonly type: "input_file";
             readonly filename: string;
-            readonly file_data?: string | undefined;
             readonly detail?: string | undefined;
+            readonly file_data?: string | undefined;
             readonly file_url?: string | undefined;
         } | {
             readonly type: "input_text";
@@ -114,8 +114,8 @@ export declare const protocol: Protocol<{
         } | {
             readonly type: "input_file";
             readonly filename: string;
-            readonly file_data?: string | undefined;
             readonly detail?: string | undefined;
+            readonly file_data?: string | undefined;
             readonly file_url?: string | undefined;
         } | {
             readonly type: "input_text";
@@ -190,21 +190,10 @@ export declare const protocol: Protocol<{
     readonly [x: string]: unknown;
     readonly type: string;
     readonly status?: unknown;
-    readonly code?: unknown;
     readonly message?: unknown;
+    readonly code?: unknown;
     readonly text?: string | undefined;
     readonly error?: unknown;
-    readonly item?: {
-        readonly [x: string]: unknown;
-        readonly type: string;
-        readonly id?: string | undefined;
-        readonly name?: string | undefined;
-        readonly namespace?: string | undefined;
-        readonly arguments?: string | undefined;
-        readonly encrypted_content?: string | null | undefined;
-        readonly call_id?: string | undefined;
-    } | null | undefined;
-    readonly delta?: string | undefined;
     readonly response?: {
         readonly [x: string]: unknown;
         readonly id?: string | undefined;
@@ -236,6 +225,17 @@ export declare const protocol: Protocol<{
             readonly reason?: string | undefined;
         } | null | undefined;
     } | undefined;
+    readonly item?: {
+        readonly [x: string]: unknown;
+        readonly type: string;
+        readonly id?: string | undefined;
+        readonly name?: string | undefined;
+        readonly namespace?: string | undefined;
+        readonly arguments?: string | undefined;
+        readonly encrypted_content?: string | null | undefined;
+        readonly call_id?: string | undefined;
+    } | null | undefined;
+    readonly delta?: string | undefined;
     readonly arguments?: string | undefined;
     readonly item_id?: string | undefined;
     readonly output_index?: number | undefined;

package/dist/protocols/anthropic-messages.js

@@ -13,6 +13,7 @@ import { JsonObject, knownString, optionalArray, optionalNull, ProviderShared }
 import { classifyProviderFailure } from "../provider-error.js";
 import { effortUpdate, resolveEffortUpdates } from "../effort-updates.js";
 import * as Cache from "./utils/cache.js";
+import { claudeVersion, supportsThinkingBlockBinding, THINKING_BINDING_BETA } from "./utils/claude-model.js";
 import { Lifecycle } from "./utils/lifecycle.js";
 import { ToolStream } from "./utils/tool-stream.js";
 const ADAPTER = "anthropic-messages";
@@ -850,20 +851,6 @@ const lowerMessages = Effect.fn("AnthropicMessages.lowerMessages")(function* (re
     }
     return messages;
 });
-// Accept gateway namespaces and Vertex suffixes without treating a snapshot date as a minor version.
-const claudeVersion = (id) => {
-    const match = /(?:^|[./])claude-(?<family>[a-z]+)-(?<major>\d+)(?:[.-](?<minor>\d{1,2}))?(?:$|[-:@])/.exec(id.toLowerCase())?.groups;
-    if (!match)
-        return undefined;
-    return { family: match.family, major: Number(match.major), minor: Number(match.minor ?? 0) };
-};
-const supportsThinkingBlockBinding = (model) => {
-    const override = model.compatibility?.supportsThinkingBlockBinding;
-    if (override !== undefined)
-        return override;
-    const version = claudeVersion(model.id);
-    return version !== undefined && (version.major > 5 || (version.major === 5 && version.minor >= 1));
-};
 const supportsEffortUpdates = (model) => {
     const override = model.compatibility?.supportsEffortUpdates;
     if (override !== undefined)
@@ -1437,7 +1424,7 @@ function requiredBetaHeaders(body) {
         betas.push("mid-conversation-output-config-2026-07-01");
     const thinking = body.thinking;
     if (thinking && thinking.type !== "disabled" && thinking.block_binding)
-        betas.push("thinking-binding-controls-2026-08-01");
+        betas.push(THINKING_BINDING_BETA);
     return betas;
 }
 export const route = Route.make({

package/dist/protocols/bedrock-converse.d.ts

@@ -141,7 +141,7 @@ interface ParserState {
     readonly hasToolCalls: boolean;
     readonly lifecycle: Lifecycle.State;
     readonly reasoningSignatures: Readonly<Record<number, string>>;
-    readonly reasoningRedactedContent: Readonly<Record<number, ReadonlyArray<Uint8Array>>>;
+    readonly reasoningRedactedContent: Readonly<Record<number, Uint8Array[]>>;
 }
 /**
  * The Bedrock Converse protocol — request body construction, body schema, and

package/dist/protocols/bedrock-converse.js

@@ -9,6 +9,7 @@ import { JsonObject, optionalArray, ProviderShared } from "./shared.js";
 import { BedrockAuth } from "./utils/bedrock-auth.js";
 import { BedrockCache } from "./utils/bedrock-cache.js";
 import { BedrockMedia } from "./utils/bedrock-media.js";
+import { supportsThinkingBlockBinding, THINKING_BINDING_BETA } from "./utils/claude-model.js";
 import { Lifecycle } from "./utils/lifecycle.js";
 import { MistralToolID } from "./utils/mistral-tool-id.js";
 import { ToolStream } from "./utils/tool-stream.js";
@@ -351,18 +352,33 @@ const Options = Schema.Struct({
 const decodeOptions = ProviderShared.validateWith(Schema.decodeUnknownEffect(Options));
 // Claude on Bedrock requires the thinking budget below `maxTokens`, with a minimum of 1,024.
 const MIN_THINKING_BUDGET = 1_024;
+const isThinkingDisabled = Schema.is(Schema.Struct({
+    additionalModelRequestFields: Schema.Struct({ thinking: Schema.Struct({ type: Schema.Literal("disabled") }) }),
+}));
+// Claude 5.1+ binds each thinking signature to the prefix above it. Ask Bedrock to drop the affected blocks instead of
+// failing when that prefix changes. `http.body` overlays this field by field, so callers can still override it.
+const applyThinkingBindingDefault = (request, thinking) => {
+    if (isThinkingDisabled(request.http?.body))
+        return thinking;
+    if (!supportsThinkingBlockBinding(request.model))
+        return thinking;
+    return {
+        ...(thinking ?? { type: "adaptive" }),
+        block_binding: { prefix_mismatch_behavior: "drop_block" },
+    };
+};
 const fromRequest = Effect.fn("BedrockConverse.fromRequest")(function* (request) {
     const toolChoice = request.toolChoice ? yield* lowerToolChoice(request.toolChoice) : undefined;
     const flattened = ProviderShared.flattenToolRequest(request);
     const generation = request.generation;
     const options = yield* decodeOptions(request.providerOptions ?? {});
     const maxTokens = isNova2(request.model) && isHighReasoningEffort(request.http?.body) ? undefined : generation?.maxTokens;
-    const thinking = options.thinking === undefined
+    const thinking = applyThinkingBindingDefault(request, options.thinking === undefined
         ? undefined
         : {
             type: "enabled",
             budget_tokens: ProviderShared.fitThinkingBudget(options.thinking.budgetTokens, maxTokens, MIN_THINKING_BUDGET),
-        };
+        });
     // Bedrock-Claude shares Anthropic's 4-breakpoint cap. Spend the budget in
     // tools → system → messages order to favour the highest-impact prefixes.
     const breakpoints = BedrockCache.breakpoints(request.model.id);
@@ -407,6 +423,8 @@ const fromRequest = Effect.fn("BedrockConverse.fromRequest")(function* (request)
             : {
                 ...(generation?.topK === undefined ? {} : { top_k: generation.topK }),
                 ...(thinking === undefined ? {} : { thinking }),
+                // Converse takes Anthropic betas in the body, and Bedrock rejects `block_binding` without this one.
+                ...(thinking?.block_binding === undefined ? {} : { anthropic_beta: [THINKING_BINDING_BETA] }),
             },
     };
 });
@@ -478,25 +496,29 @@ const step = (state, event) => Effect.gen(function* () {
         const index = event.contentBlockDelta.contentBlockIndex;
         const reasoning = event.contentBlockDelta.delta.reasoningContent;
         const events = [];
-        const redactedChunks = yield* (() => {
+        const redactedChunk = yield* (() => {
             if (reasoning.redactedContent === undefined)
                 return Effect.succeed(undefined);
-            return Effect.fromResult(Encoding.decodeBase64(reasoning.redactedContent)).pipe(Effect.map((chunk) => [...(state.reasoningRedactedContent[index] ?? []), chunk]), Effect.mapError((cause) => ProviderShared.eventError(ADAPTER, "Bedrock Converse reasoningContent.redactedContent contains invalid base64 data", undefined, cause)));
+            return Effect.fromResult(Encoding.decodeBase64(reasoning.redactedContent)).pipe(Effect.mapError((cause) => ProviderShared.eventError(ADAPTER, "Bedrock Converse reasoningContent.redactedContent contains invalid base64 data", undefined, cause)));
         })();
-        const redactedData = redactedChunks === undefined ? reasoning.data : encodeRedactedContent(redactedChunks);
+        const redactedChunks = state.reasoningRedactedContent[index] ?? [];
+        if (redactedChunk !== undefined)
+            redactedChunks.push(redactedChunk);
         const metadata = (() => {
             if (reasoning.signature)
                 return providerMetadata(state.providerMetadataKey, { signature: reasoning.signature });
-            if (redactedData !== undefined)
-                return providerMetadata(state.providerMetadataKey, { redactedData });
+            if (redactedChunk === undefined && reasoning.data !== undefined)
+                return providerMetadata(state.providerMetadataKey, { redactedData: reasoning.data });
         })();
         const lifecycle = (() => {
-            if (reasoning.text === undefined && metadata === undefined)
-                return state.lifecycle;
-            return Lifecycle.reasoningDelta(state.lifecycle, events, `reasoning-${index}`, reasoning.text ?? "", metadata);
+            if (reasoning.text !== undefined || metadata !== undefined)
+                return Lifecycle.reasoningDelta(state.lifecycle, events, `reasoning-${index}`, reasoning.text ?? "", metadata);
+            if (redactedChunk !== undefined)
+                return Lifecycle.reasoningStart(state.lifecycle, events, `reasoning-${index}`);
+            return state.lifecycle;
         })();
         const reasoningRedactedContent = (() => {
-            if (redactedChunks !== undefined)
+            if (redactedChunk !== undefined)
                 return { ...state.reasoningRedactedContent, [index]: redactedChunks };
             if (reasoning.data === undefined)
                 return state.reasoningRedactedContent;
@@ -609,7 +631,11 @@ const onHalt = (state) => {
         return state.finishReason.normalized;
     })();
     const events = [];
-    Lifecycle.finish(state.lifecycle, events, {
+    const lifecycle = Object.entries(state.reasoningRedactedContent).reduce((current, [index, chunks]) => {
+        const signature = state.reasoningSignatures[Number(index)];
+        return Lifecycle.reasoningEnd(current, events, `reasoning-${index}`, providerMetadata(state.providerMetadataKey, signature ? { signature } : { redactedData: encodeRedactedContent(chunks) }));
+    }, state.lifecycle);
+    Lifecycle.finish(lifecycle, events, {
         reason: {
             ...state.finishReason,
             normalized,

package/dist/protocols/meta-messages.d.ts

@@ -203,11 +203,15 @@ export declare const protocol: Protocol<{
             readonly timezone?: string | undefined;
         } | undefined;
     } | {
-        readonly name: string;
         readonly description: string;
+        readonly name: string;
         readonly input_schema: {
             readonly [x: string]: unknown;
         };
+        readonly cache_control?: {
+            readonly type: "ephemeral";
+            readonly ttl?: "1h" | "5m" | undefined;
+        } | undefined;
     })[] | undefined;
     readonly system?: readonly {
         readonly type: "text";

package/dist/protocols/meta-messages.js

@@ -8,12 +8,19 @@ const WebSearch = Schema.Struct({
     name: Schema.Literal("web_search"),
     user_location: MetaResponses.WebSearch.fields.user_location,
 });
+const MetaCacheControl = Schema.Struct({
+    type: Schema.tag("ephemeral"),
+    ttl: Schema.optional(Schema.Literals(["5m", "1h"])),
+});
+const FunctionTool = Schema.Struct({
+    name: Schema.String,
+    description: Schema.String,
+    input_schema: JsonObject,
+    cache_control: Schema.optional(MetaCacheControl),
+});
 const Body = Schema.Struct({
     ...AnthropicMessages.AnthropicMessagesBody.fields,
-    tools: optionalArray(Schema.Union([
-        Schema.Struct({ name: Schema.String, description: Schema.String, input_schema: JsonObject }),
-        WebSearch,
-    ])),
+    tools: optionalArray(Schema.Union([FunctionTool, WebSearch])),
 });
 const fromRequest = Effect.fn("MetaMessages.fromRequest")(function* (request) {
     const projected = ProviderShared.flattenToolRequest(request);

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

@@ -92,8 +92,8 @@ export declare const protocol: Protocol<{
         } | {
             readonly type: "input_file";
             readonly filename: string;
-            readonly file_data?: string | undefined;
             readonly detail?: string | undefined;
+            readonly file_data?: string | undefined;
             readonly file_url?: string | undefined;
         } | {
             readonly type: "input_text";
@@ -129,8 +129,8 @@ export declare const protocol: Protocol<{
         } | {
             readonly type: "input_file";
             readonly filename: string;
-            readonly file_data?: string | undefined;
             readonly detail?: string | undefined;
+            readonly file_data?: string | undefined;
             readonly file_url?: string | undefined;
         } | {
             readonly type: "input_text";
@@ -219,21 +219,10 @@ export declare const protocol: Protocol<{
     readonly [x: string]: unknown;
     readonly type: string;
     readonly status?: unknown;
-    readonly code?: unknown;
     readonly message?: unknown;
+    readonly code?: unknown;
     readonly text?: string | undefined;
     readonly error?: unknown;
-    readonly item?: {
-        readonly [x: string]: unknown;
-        readonly type: string;
-        readonly id?: string | undefined;
-        readonly name?: string | undefined;
-        readonly namespace?: string | undefined;
-        readonly arguments?: string | undefined;
-        readonly encrypted_content?: string | null | undefined;
-        readonly call_id?: string | undefined;
-    } | null | undefined;
-    readonly delta?: string | undefined;
     readonly response?: {
         readonly [x: string]: unknown;
         readonly id?: string | undefined;
@@ -265,6 +254,17 @@ export declare const protocol: Protocol<{
             readonly reason?: string | undefined;
         } | null | undefined;
     } | undefined;
+    readonly item?: {
+        readonly [x: string]: unknown;
+        readonly type: string;
+        readonly id?: string | undefined;
+        readonly name?: string | undefined;
+        readonly namespace?: string | undefined;
+        readonly arguments?: string | undefined;
+        readonly encrypted_content?: string | null | undefined;
+        readonly call_id?: string | undefined;
+    } | null | undefined;
+    readonly delta?: string | undefined;
     readonly arguments?: string | undefined;
     readonly item_id?: string | undefined;
     readonly output_index?: number | undefined;
@@ -338,8 +338,8 @@ export declare const httpTransport: HttpTransport.HttpJsonTransport<{
         } | {
             readonly type: "input_file";
             readonly filename: string;
-            readonly file_data?: string | undefined;
             readonly detail?: string | undefined;
+            readonly file_data?: string | undefined;
             readonly file_url?: string | undefined;
         } | {
             readonly type: "input_text";
@@ -375,8 +375,8 @@ export declare const httpTransport: HttpTransport.HttpJsonTransport<{
         } | {
             readonly type: "input_file";
             readonly filename: string;
-            readonly file_data?: string | undefined;
             readonly detail?: string | undefined;
+            readonly file_data?: string | undefined;
             readonly file_url?: string | undefined;
         } | {
             readonly type: "input_text";

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

@@ -8,6 +8,11 @@ import { Lifecycle } from "./utils/lifecycle.js";
 import { ToolStream } from "./utils/tool-stream.js";
 export declare const DEFAULT_BASE_URL = "https://api.mistral.ai/v1";
 export declare const PATH = "/chat/completions";
+declare const MistralThinkingUnit: Schema.StructWithRest<Schema.Struct<{
+    readonly type: Schema.optional<Schema.String>;
+    readonly text: Schema.optional<Schema.String>;
+}>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>;
+type MistralThinkingUnit = Schema.Schema.Type<typeof MistralThinkingUnit>;
 declare const MistralThinkingContent: Schema.StructWithRest<Schema.Struct<{
     readonly type: Schema.Literal<"thinking">;
     readonly thinking: Schema.$Array<Schema.StructWithRest<Schema.Struct<{
@@ -212,6 +217,7 @@ interface ActiveContent {
     readonly type: "text" | "reasoning";
     readonly id: string;
     readonly thinking?: MistralThinkingContent;
+    readonly thinkingUnits?: MistralThinkingUnit[];
 }
 export interface ParserState {
     readonly tools: ToolStream.State<ToolKey>;

package/dist/protocols/mistral-chat.js

@@ -365,7 +365,7 @@ const closeActive = (state, events) => {
         return state;
     const lifecycle = state.active.type === "text"
         ? Lifecycle.textEnd(state.lifecycle, events, state.active.id)
-        : Lifecycle.reasoningEnd(state.lifecycle, events, state.active.id, thinkingMetadata(state.active.thinking ?? { type: "thinking", thinking: [] }), thinkingText(state.active.thinking?.thinking ?? []));
+        : Lifecycle.reasoningEnd(state.lifecycle, events, state.active.id, thinkingMetadata({ ...state.active.thinking, type: "thinking", thinking: state.active.thinkingUnits ?? [] }), thinkingText(state.active.thinkingUnits ?? []));
     return { ...state, lifecycle, active: undefined };
 };
 const appendText = (state, events, text) => {
@@ -384,19 +384,22 @@ const appendThinking = (state, events, part) => {
     const current = state.active?.type === "reasoning" ? state : closeActive(state, events);
     const units = thinkingUnits(part.thinking);
     const active = current.active ?? { type: "reasoning", id: `reasoning-${current.nextContent}` };
+    // Keep native units out of streamed events until the block is complete.
+    const accumulated = active.thinkingUnits ?? [];
+    accumulated.push(...units);
     const thinking = {
         ...active.thinking,
         ...part,
         type: "thinking",
-        thinking: [...(active.thinking?.thinking ?? []), ...units],
+        thinking: [],
     };
     const text = thinkingText(units);
     return {
         ...current,
         lifecycle: text.length > 0
-            ? Lifecycle.reasoningDelta(current.lifecycle, events, active.id, text, thinkingMetadata(thinking))
-            : Lifecycle.reasoningStart(current.lifecycle, events, active.id, thinkingMetadata(thinking)),
-        active: { ...active, thinking },
+            ? Lifecycle.reasoningDelta(current.lifecycle, events, active.id, text)
+            : Lifecycle.reasoningStart(current.lifecycle, events, active.id),
+        active: { ...active, thinking, thinkingUnits: accumulated },
         nextContent: current.active ? current.nextContent : current.nextContent + 1,
     };
 };

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

@@ -629,21 +629,10 @@ export declare const decodeChannelEvent: (frame: string) => Effect.Effect<{
     readonly [x: string]: unknown;
     readonly type: string;
     readonly status?: unknown;
-    readonly code?: unknown;
     readonly message?: unknown;
+    readonly code?: unknown;
     readonly text?: string | undefined;
     readonly error?: unknown;
-    readonly item?: {
-        readonly [x: string]: unknown;
-        readonly type: string;
-        readonly id?: string | undefined;
-        readonly name?: string | undefined;
-        readonly namespace?: string | undefined;
-        readonly arguments?: string | undefined;
-        readonly encrypted_content?: string | null | undefined;
-        readonly call_id?: string | undefined;
-    } | null | undefined;
-    readonly delta?: string | undefined;
     readonly response?: {
         readonly [x: string]: unknown;
         readonly id?: string | undefined;
@@ -675,6 +664,17 @@ export declare const decodeChannelEvent: (frame: string) => Effect.Effect<{
             readonly reason?: string | undefined;
         } | null | undefined;
     } | undefined;
+    readonly item?: {
+        readonly [x: string]: unknown;
+        readonly type: string;
+        readonly id?: string | undefined;
+        readonly name?: string | undefined;
+        readonly namespace?: string | undefined;
+        readonly arguments?: string | undefined;
+        readonly encrypted_content?: string | null | undefined;
+        readonly call_id?: string | undefined;
+    } | null | undefined;
+    readonly delta?: string | undefined;
     readonly arguments?: string | undefined;
     readonly item_id?: string | undefined;
     readonly output_index?: number | undefined;
@@ -896,8 +896,8 @@ export declare const fromRequest: (request: LLMRequest<import("../schema/options
         } | {
             readonly type: "input_file";
             readonly filename: string;
-            readonly file_data?: string | undefined;
             readonly detail?: string | undefined;
+            readonly file_data?: string | undefined;
             readonly file_url?: string | undefined;
         } | {
             readonly type: "input_text";
@@ -933,8 +933,8 @@ export declare const fromRequest: (request: LLMRequest<import("../schema/options
         } | {
             readonly type: "input_file";
             readonly filename: string;
-            readonly file_data?: string | undefined;
             readonly detail?: string | undefined;
+            readonly file_data?: string | undefined;
             readonly file_url?: string | undefined;
         } | {
             readonly type: "input_text";
@@ -1169,8 +1169,8 @@ export declare const step: (state: ParserState, event: NormalizedEvent) => AIErr
 } | {
     readonly id: string;
     readonly type: "tool-error";
-    readonly name: string;
     readonly message: string;
+    readonly name: string;
     readonly error?: unknown;
     readonly providerMetadata?: {
         readonly [x: string]: {
@@ -1293,8 +1293,8 @@ export declare const protocol: Protocol<{
         } | {
             readonly type: "input_file";
             readonly filename: string;
-            readonly file_data?: string | undefined;
             readonly detail?: string | undefined;
+            readonly file_data?: string | undefined;
             readonly file_url?: string | undefined;
         } | {
             readonly type: "input_text";
@@ -1330,8 +1330,8 @@ export declare const protocol: Protocol<{
         } | {
             readonly type: "input_file";
             readonly filename: string;
-            readonly file_data?: string | undefined;
             readonly detail?: string | undefined;
+            readonly file_data?: string | undefined;
             readonly file_url?: string | undefined;
         } | {
             readonly type: "input_text";
@@ -1395,21 +1395,10 @@ export declare const protocol: Protocol<{
     readonly [x: string]: unknown;
     readonly type: string;
     readonly status?: unknown;
-    readonly code?: unknown;
     readonly message?: unknown;
+    readonly code?: unknown;
     readonly text?: string | undefined;
     readonly error?: unknown;
-    readonly item?: {
-        readonly [x: string]: unknown;
-        readonly type: string;
-        readonly id?: string | undefined;
-        readonly name?: string | undefined;
-        readonly namespace?: string | undefined;
-        readonly arguments?: string | undefined;
-        readonly encrypted_content?: string | null | undefined;
-        readonly call_id?: string | undefined;
-    } | null | undefined;
-    readonly delta?: string | undefined;
     readonly response?: {
         readonly [x: string]: unknown;
         readonly id?: string | undefined;
@@ -1441,6 +1430,17 @@ export declare const protocol: Protocol<{
             readonly reason?: string | undefined;
         } | null | undefined;
     } | undefined;
+    readonly item?: {
+        readonly [x: string]: unknown;
+        readonly type: string;
+        readonly id?: string | undefined;
+        readonly name?: string | undefined;
+        readonly namespace?: string | undefined;
+        readonly arguments?: string | undefined;
+        readonly encrypted_content?: string | null | undefined;
+        readonly call_id?: string | undefined;
+    } | null | undefined;
+    readonly delta?: string | undefined;
     readonly arguments?: string | undefined;
     readonly item_id?: string | undefined;
     readonly output_index?: number | undefined;
@@ -1514,8 +1514,8 @@ export declare const httpTransport: HttpTransport.HttpJsonTransport<{
         } | {
             readonly type: "input_file";
             readonly filename: string;
-            readonly file_data?: string | undefined;
             readonly detail?: string | undefined;
+            readonly file_data?: string | undefined;
             readonly file_url?: string | undefined;
         } | {
             readonly type: "input_text";
@@ -1551,8 +1551,8 @@ export declare const httpTransport: HttpTransport.HttpJsonTransport<{
         } | {
             readonly type: "input_file";
             readonly filename: string;
-            readonly file_data?: string | undefined;
             readonly detail?: string | undefined;
+            readonly file_data?: string | undefined;
             readonly file_url?: string | undefined;
         } | {
             readonly type: "input_text";