@opencode/ai 2.0.23 → 2.0.25

package/README.md

@@ -1283,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, 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.
+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, Vercel AI Gateway, 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

@@ -46,21 +46,22 @@ const RESPECTS_INLINE_HINTS = new Set([
     "meta-messages",
     "minimax-messages",
     "moonshot-messages",
+    "vercel-ai-gateway-messages",
     "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.
+// OpenRouter and Vercel AI Gateway 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) => {
+const gatewayPolicy = (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/"))
+    if (id.startsWith("qwen/") || id.startsWith("alibaba/qwen"))
         return QWEN;
     return NONE;
 };
@@ -142,11 +143,13 @@ const countHints = (request) => countToolHints(request.tools) +
     request.messages.reduce((count, message) => count +
         message.content.reduce((contentCount, part) => contentCount + ("cache" in part && part.cache !== undefined ? 1 : 0), 0), 0);
 export const applyCachePolicy = (request) => {
-    if (!RESPECTS_INLINE_HINTS.has(request.model.route.id))
+    const route = request.model.route.id;
+    if (!RESPECTS_INLINE_HINTS.has(route))
         return request;
-    const policy = request.model.route.id === "openrouter" && (request.cache === undefined || request.cache === "auto")
-        ? openRouterPolicy(request.model.id)
-        : request.model.route.id === "alibaba-chat" && (request.cache === undefined || request.cache === "auto")
+    const policy = (route === "openrouter" || route === "vercel-ai-gateway-messages") &&
+        (request.cache === undefined || request.cache === "auto")
+        ? gatewayPolicy(request.model.id)
+        : route === "alibaba-chat" && (request.cache === undefined || request.cache === "auto")
             ? request.model.id.toLowerCase().startsWith("qwen")
                 ? QWEN
                 : NONE

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

@@ -272,8 +272,10 @@ export declare const protocol: Protocol<{
     readonly top_k?: number | undefined;
     readonly stop_sequences?: readonly string[] | undefined;
 }, string, {
+    readonly [x: string]: unknown;
     readonly type: string;
     readonly message?: {
+        readonly [x: string]: unknown;
         readonly usage?: {
             readonly [x: string]: unknown;
             readonly input_tokens?: number | null | undefined;
@@ -306,6 +308,7 @@ export declare const protocol: Protocol<{
         } | undefined;
     } | undefined;
     readonly error?: {
+        readonly [x: string]: unknown;
         readonly type?: string | undefined;
         readonly message?: string | undefined;
     } | undefined;

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

@@ -213,13 +213,16 @@ export declare const protocol: Protocol<{
         }[] | undefined;
         readonly error?: unknown;
         readonly usage?: {
+            readonly [x: string]: unknown;
             readonly input_tokens?: number | undefined;
             readonly output_tokens?: number | undefined;
             readonly output_tokens_details?: {
+                readonly [x: string]: unknown;
                 readonly reasoning_tokens?: number | undefined;
             } | null | undefined;
             readonly total_tokens?: number | undefined;
             readonly input_tokens_details?: {
+                readonly [x: string]: unknown;
                 readonly cached_tokens?: number | undefined;
                 readonly cache_write_tokens?: number | undefined;
             } | null | undefined;

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

@@ -58,7 +58,7 @@ declare const Thinking: Schema.Union<readonly [Schema.decodeTo<Schema.Struct<{
     }>>;
     readonly type: Schema.tag<"adaptive">;
 }>, Schema.Struct<{
-    readonly type: Schema.tag<"disabled">;
+    readonly type: Schema.Literals<readonly ["disabled", "between_tools"]>;
 }>]>;
 declare const Options: Schema.Struct<{
     /** Advanced in-band compaction. The caller owns checkpoint persistence and recovery. */
@@ -101,7 +101,7 @@ declare const Options: Schema.Struct<{
         }>>;
         readonly type: Schema.tag<"adaptive">;
     }>, Schema.Struct<{
-        readonly type: Schema.tag<"disabled">;
+        readonly type: Schema.Literals<readonly ["disabled", "between_tools"]>;
     }>]>>;
     readonly effort: Schema.optional<Schema.String>;
     readonly service_tier: Schema.optional<Schema.declare<import("../schema/options.js").OpenString<"auto" | "standard_only">, import("../schema/options.js").OpenString<"auto" | "standard_only">>>;
@@ -382,7 +382,7 @@ export declare const AnthropicMessagesBody: Schema.Struct<{
         }>>;
         readonly type: Schema.tag<"adaptive">;
     }>, Schema.Struct<{
-        readonly type: Schema.tag<"disabled">;
+        readonly type: Schema.Literals<readonly ["disabled", "between_tools"]>;
     }>]>>;
     output_config: Schema.optional<Schema.Struct<{
         readonly effort: Schema.optional<Schema.String>;
@@ -638,7 +638,7 @@ export declare const protocol: Protocol<{
             readonly prefix_mismatch_behavior?: import("../schema/options.js").OpenString<"error" | "drop_block"> | undefined;
         } | undefined;
     } | {
-        readonly type: "disabled";
+        readonly type: "disabled" | "between_tools";
     } | undefined;
     readonly service_tier?: import("../schema/options.js").OpenString<"auto" | "standard_only"> | undefined;
     readonly container?: string | {
@@ -684,8 +684,10 @@ export declare const protocol: Protocol<{
     readonly top_k?: number | undefined;
     readonly stop_sequences?: readonly string[] | undefined;
 }, string, {
+    readonly [x: string]: unknown;
     readonly type: string;
     readonly message?: {
+        readonly [x: string]: unknown;
         readonly usage?: {
             readonly [x: string]: unknown;
             readonly input_tokens?: number | null | undefined;
@@ -718,6 +720,7 @@ export declare const protocol: Protocol<{
         } | undefined;
     } | undefined;
     readonly error?: {
+        readonly [x: string]: unknown;
         readonly type?: string | undefined;
         readonly message?: string | undefined;
     } | undefined;
@@ -995,7 +998,7 @@ export declare const route: Route<{
             readonly prefix_mismatch_behavior?: import("../schema/options.js").OpenString<"error" | "drop_block"> | undefined;
         } | undefined;
     } | {
-        readonly type: "disabled";
+        readonly type: "disabled" | "between_tools";
     } | undefined;
     readonly service_tier?: import("../schema/options.js").OpenString<"auto" | "standard_only"> | undefined;
     readonly container?: string | {

package/dist/protocols/anthropic-messages.js

@@ -223,7 +223,7 @@ const AnthropicThinkingEnabled = Schema.Struct({
     ...AnthropicThinkingFields,
 });
 const AnthropicThinkingAdaptive = Schema.Struct({ type: Schema.tag("adaptive"), ...AnthropicThinkingFields });
-const AnthropicThinkingDisabled = Schema.Struct({ type: Schema.tag("disabled") });
+const AnthropicThinkingDisabled = Schema.Struct({ type: Schema.Literals(["disabled", "between_tools"]) });
 const AnthropicThinking = Schema.Union([AnthropicThinkingEnabled, AnthropicThinkingAdaptive, AnthropicThinkingDisabled]);
 // SDK OutputConfig:2684 {effort?: "low"|"medium"|"high"|"xhigh"|"max"|null, format?: JSONOutputFormat:2399}
 const AnthropicJsonOutputFormat = Schema.Struct({
@@ -332,7 +332,7 @@ const AnthropicUsage = Schema.StructWithRest(Schema.Struct({
     ...AnthropicIterationUsage.schema.fields,
     iterations: Schema.optional(Schema.Array(AnthropicIterationUsage)),
 }), [JsonObject]);
-const AnthropicStreamBlock = Schema.Struct({
+const AnthropicStreamBlock = Schema.StructWithRest(Schema.Struct({
     type: Schema.String,
     id: Schema.optional(Schema.String),
     name: Schema.optional(Schema.String),
@@ -348,9 +348,9 @@ const AnthropicStreamBlock = Schema.Struct({
     // server_tool_use id in `tool_use_id`.
     tool_use_id: Schema.optional(Schema.String),
     content: Schema.optional(Schema.Unknown),
-});
+}), [JsonObject]);
 const decodeAnthropicStreamBlock = Schema.decodeUnknownOption(AnthropicStreamBlock);
-const AnthropicStreamDelta = Schema.Struct({
+const AnthropicStreamDelta = Schema.StructWithRest(Schema.Struct({
     content: optionalNull(Schema.String),
     type: Schema.optional(Schema.String),
     text: Schema.optional(Schema.String),
@@ -359,13 +359,13 @@ 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) })),
-});
+    stop_details: optionalNull(Schema.StructWithRest(Schema.Struct({ category: optionalNull(Schema.String), explanation: optionalNull(Schema.String) }), [JsonObject])),
+}), [JsonObject]);
 const decodeAnthropicStreamDelta = Schema.decodeUnknownOption(AnthropicStreamDelta);
-const AnthropicEvent = Schema.Struct({
+const AnthropicEvent = Schema.StructWithRest(Schema.Struct({
     type: Schema.String,
     index: Schema.optional(Schema.Number),
-    message: Schema.optional(Schema.Struct({ usage: Schema.optional(AnthropicUsage) })),
+    message: Schema.optional(Schema.StructWithRest(Schema.Struct({ usage: Schema.optional(AnthropicUsage) }), [JsonObject])),
     content_block: Schema.optional(Schema.Unknown),
     delta: Schema.optional(Schema.Unknown),
     usage: Schema.optional(AnthropicUsage),
@@ -373,8 +373,8 @@ const AnthropicEvent = Schema.Struct({
     // OpenAI-compatible proxies and gateway translations occasionally drop one
     // or the other; mark them optional so a partial payload still parses and
     // the parser can fall back to whichever field is populated.
-    error: Schema.optional(Schema.Struct({ type: Schema.optional(Schema.String), message: Schema.optional(Schema.String) })),
-});
+    error: Schema.optional(Schema.StructWithRest(Schema.Struct({ type: Schema.optional(Schema.String), message: Schema.optional(Schema.String) }), [JsonObject])),
+}), [JsonObject]);
 const invalid = ProviderShared.invalidRequest;
 // =============================================================================
 // Request Lowering
@@ -855,12 +855,15 @@ const lowerMessages = Effect.fnUntraced(function* (request, breakpoints) {
 // TODO: Move per-model capability heuristics (`supportsEffortUpdates`, `supportsNativeSystemUpdates`,
 // `supportsThinkingBlockBinding`) into explicit model/provider `compatibility` metadata so the protocol
 // only reads `request.model.compatibility`.
+const isThinkingOff = Schema.is(AnthropicThinkingDisabled);
 // 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;
+const supportsEffortUpdates = (request) => {
+    if (isThinkingOff(request.providerOptions?.thinking))
+        return false;
+    const override = request.model.compatibility?.supportsEffortUpdates;
     if (override !== undefined)
         return override;
-    const version = claudeVersion(model.id);
+    const version = claudeVersion(request.model.id);
     if (version === undefined)
         return false;
     if (version.family === "opus" && version.major >= 5)
@@ -868,7 +871,7 @@ const supportsEffortUpdates = (model) => {
     return version.major > 5 || (version.major === 5 && version.minor >= 1);
 };
 const applyThinkingBindingDefault = (model, thinking) => {
-    if (thinking?.type === "disabled")
+    if (isThinkingOff(thinking))
         return thinking;
     if (!supportsThinkingBlockBinding(model))
         return thinking;
@@ -1390,7 +1393,7 @@ export const protocol = Protocol.make({
         }),
         step,
     },
-    supportsEffortUpdates: (request) => supportsEffortUpdates(request.model),
+    supportsEffortUpdates,
 });
 export const transport = () => {
     const http = HttpTransport.httpJson({ framing });
@@ -1430,7 +1433,7 @@ function requiredBetaHeaders(body) {
     if (body.messages.some((message) => message.role === "system" && message.output_config !== undefined))
         betas.push("mid-conversation-output-config-2026-07-01");
     const thinking = body.thinking;
-    if (thinking && thinking.type !== "disabled" && thinking.block_binding)
+    if (thinking && !isThinkingOff(thinking) && thinking.block_binding)
         betas.push(THINKING_BINDING_BETA);
     return betas;
 }

package/dist/protocols/bedrock-converse.js

@@ -382,7 +382,9 @@ const decodeOptions = ProviderShared.validateWith(Schema.decodeUnknownEffect(Opt
 // 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") }) }),
+    additionalModelRequestFields: Schema.Struct({
+        thinking: Schema.Struct({ type: Schema.Literals(["disabled", "between_tools"]) }),
+    }),
 }));
 // 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.

package/dist/protocols/google-interactions.d.ts

@@ -9,7 +9,7 @@ declare const Options: Schema.Struct<{
     readonly store: Schema.optionalKey<Schema.middlewareDecoding<Schema.UndefinedOr<Schema.Boolean>, never>>;
     readonly thinkingLevel: Schema.optionalKey<Schema.middlewareDecoding<Schema.UndefinedOr<Schema.declare<import("../schema/options.js").OpenString<"minimal" | "low" | "medium" | "high">, import("../schema/options.js").OpenString<"minimal" | "low" | "medium" | "high">>>, never>>;
     readonly thinkingSummaries: Schema.optionalKey<Schema.middlewareDecoding<Schema.UndefinedOr<Schema.declare<import("../schema/options.js").OpenString<"auto" | "none">, import("../schema/options.js").OpenString<"auto" | "none">>>, never>>;
-    readonly serviceTier: Schema.optionalKey<Schema.middlewareDecoding<Schema.UndefinedOr<Schema.declare<import("../schema/options.js").OpenString<"standard" | "flex" | "priority">, import("../schema/options.js").OpenString<"standard" | "flex" | "priority">>>, never>>;
+    readonly serviceTier: Schema.optionalKey<Schema.middlewareDecoding<Schema.UndefinedOr<Schema.declare<import("../schema/options.js").OpenString<"standard" | "flex" | "priority" | "deferred">, import("../schema/options.js").OpenString<"standard" | "flex" | "priority" | "deferred">>>, never>>;
 }>;
 export type OptionsInput = typeof Options.Encoded;
 export type ProviderOptionsInput = OptionsInput;

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

@@ -236,7 +236,7 @@ export declare const protocol: Protocol<{
             readonly prefix_mismatch_behavior?: import("../schema/options.js").OpenString<"error" | "drop_block"> | undefined;
         } | undefined;
     } | {
-        readonly type: "disabled";
+        readonly type: "disabled" | "between_tools";
     } | undefined;
     readonly service_tier?: import("../schema/options.js").OpenString<"auto" | "standard_only"> | undefined;
     readonly container?: string | {
@@ -282,8 +282,10 @@ export declare const protocol: Protocol<{
     readonly top_k?: number | undefined;
     readonly stop_sequences?: readonly string[] | undefined;
 }, string, {
+    readonly [x: string]: unknown;
     readonly type: string;
     readonly message?: {
+        readonly [x: string]: unknown;
         readonly usage?: {
             readonly [x: string]: unknown;
             readonly input_tokens?: number | null | undefined;
@@ -316,6 +318,7 @@ export declare const protocol: Protocol<{
         } | undefined;
     } | undefined;
     readonly error?: {
+        readonly [x: string]: unknown;
         readonly type?: string | undefined;
         readonly message?: string | undefined;
     } | undefined;

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

@@ -224,13 +224,16 @@ export declare const protocol: Protocol<{
         }[] | undefined;
         readonly error?: unknown;
         readonly usage?: {
+            readonly [x: string]: unknown;
             readonly input_tokens?: number | undefined;
             readonly output_tokens?: number | undefined;
             readonly output_tokens_details?: {
+                readonly [x: string]: unknown;
                 readonly reasoning_tokens?: number | undefined;
             } | null | undefined;
             readonly total_tokens?: number | undefined;
             readonly input_tokens_details?: {
+                readonly [x: string]: unknown;
                 readonly cached_tokens?: number | undefined;
                 readonly cache_write_tokens?: number | undefined;
             } | null | undefined;

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

@@ -559,18 +559,18 @@ export declare const OpenResponsesBody: Schema.Struct<{
     readonly frequency_penalty: Schema.optional<Schema.Number>;
 }>;
 export type OpenResponsesBody = Schema.Schema.Type<typeof OpenResponsesBody>;
-export declare const OpenResponsesUsage: Schema.Struct<{
+export declare const OpenResponsesUsage: Schema.StructWithRest<Schema.Struct<{
     readonly input_tokens: Schema.optional<Schema.Number>;
-    readonly input_tokens_details: Schema.optional<Schema.NullOr<Schema.Struct<{
+    readonly input_tokens_details: Schema.optional<Schema.NullOr<Schema.StructWithRest<Schema.Struct<{
         readonly cached_tokens: Schema.optional<Schema.Number>;
         readonly cache_write_tokens: Schema.optional<Schema.Number>;
-    }>>>;
+    }>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>>>;
     readonly output_tokens: Schema.optional<Schema.Number>;
-    readonly output_tokens_details: Schema.optional<Schema.NullOr<Schema.Struct<{
+    readonly output_tokens_details: Schema.optional<Schema.NullOr<Schema.StructWithRest<Schema.Struct<{
         readonly reasoning_tokens: Schema.optional<Schema.Number>;
-    }>>>;
+    }>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>>>;
     readonly total_tokens: Schema.optional<Schema.Number>;
-}>;
+}>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>;
 type OpenResponsesUsage = Schema.Schema.Type<typeof OpenResponsesUsage>;
 export declare const StreamItem: Schema.StructWithRest<Schema.Struct<{
     readonly type: Schema.String;
@@ -617,18 +617,18 @@ export declare const Event: Schema.StructWithRest<Schema.Struct<{
             readonly arguments: Schema.optional<Schema.String>;
             readonly encrypted_content: Schema.optional<Schema.NullOr<Schema.String>>;
         }>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>>>;
-        readonly usage: Schema.optional<Schema.NullOr<Schema.Struct<{
+        readonly usage: Schema.optional<Schema.NullOr<Schema.StructWithRest<Schema.Struct<{
             readonly input_tokens: Schema.optional<Schema.Number>;
-            readonly input_tokens_details: Schema.optional<Schema.NullOr<Schema.Struct<{
+            readonly input_tokens_details: Schema.optional<Schema.NullOr<Schema.StructWithRest<Schema.Struct<{
                 readonly cached_tokens: Schema.optional<Schema.Number>;
                 readonly cache_write_tokens: Schema.optional<Schema.Number>;
-            }>>>;
+            }>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>>>;
             readonly output_tokens: Schema.optional<Schema.Number>;
-            readonly output_tokens_details: Schema.optional<Schema.NullOr<Schema.Struct<{
+            readonly output_tokens_details: Schema.optional<Schema.NullOr<Schema.StructWithRest<Schema.Struct<{
                 readonly reasoning_tokens: Schema.optional<Schema.Number>;
-            }>>>;
+            }>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>>>;
             readonly total_tokens: Schema.optional<Schema.Number>;
-        }>>>;
+        }>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>>>;
         readonly error: Schema.optional<Schema.Unknown>;
     }>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>>;
     readonly code: Schema.optional<Schema.Unknown>;
@@ -669,13 +669,16 @@ export declare const decodeChannelEvent: (frame: string) => Effect.Effect<{
         }[] | undefined;
         readonly error?: unknown;
         readonly usage?: {
+            readonly [x: string]: unknown;
             readonly input_tokens?: number | undefined;
             readonly output_tokens?: number | undefined;
             readonly output_tokens_details?: {
+                readonly [x: string]: unknown;
                 readonly reasoning_tokens?: number | undefined;
             } | null | undefined;
             readonly total_tokens?: number | undefined;
             readonly input_tokens_details?: {
+                readonly [x: string]: unknown;
                 readonly cached_tokens?: number | undefined;
                 readonly cache_write_tokens?: number | undefined;
             } | null | undefined;
@@ -1721,13 +1724,16 @@ export declare const protocol: Protocol<{
         }[] | undefined;
         readonly error?: unknown;
         readonly usage?: {
+            readonly [x: string]: unknown;
             readonly input_tokens?: number | undefined;
             readonly output_tokens?: number | undefined;
             readonly output_tokens_details?: {
+                readonly [x: string]: unknown;
                 readonly reasoning_tokens?: number | undefined;
             } | null | undefined;
             readonly total_tokens?: number | undefined;
             readonly input_tokens_details?: {
+                readonly [x: string]: unknown;
                 readonly cached_tokens?: number | undefined;
                 readonly cache_write_tokens?: number | undefined;
             } | null | undefined;

package/dist/protocols/open-responses.js

@@ -221,16 +221,16 @@ export const OpenResponsesBody = Schema.Struct({
     ...coreFields,
     stream: Schema.Literal(true),
 });
-export const OpenResponsesUsage = Schema.Struct({
+export const OpenResponsesUsage = Schema.StructWithRest(Schema.Struct({
     input_tokens: Schema.optional(Schema.Number),
-    input_tokens_details: optionalNull(Schema.Struct({
+    input_tokens_details: optionalNull(Schema.StructWithRest(Schema.Struct({
         cached_tokens: Schema.optional(Schema.Number),
         cache_write_tokens: Schema.optional(Schema.Number),
-    })),
+    }), [JsonObject])),
     output_tokens: Schema.optional(Schema.Number),
-    output_tokens_details: optionalNull(Schema.Struct({ reasoning_tokens: Schema.optional(Schema.Number) })),
+    output_tokens_details: optionalNull(Schema.StructWithRest(Schema.Struct({ reasoning_tokens: Schema.optional(Schema.Number) }), [JsonObject])),
     total_tokens: Schema.optional(Schema.Number),
-});
+}), [JsonObject]);
 // The spec requires `id` on every output item, but some gateways drop it from
 // later item events (Bedrock Mantle renames it to `item_id` on
 // `output_item.done` and `response.completed.output`). Decode it as optional
@@ -336,6 +336,8 @@ const lowerReasoning = (part, providerMetadataKey) => {
     const encryptedContent = typeof metadata.reasoningEncryptedContent === "string" || metadata.reasoningEncryptedContent === null
         ? metadata.reasoningEncryptedContent
         : undefined;
+    if (part.text.length === 0 && !encryptedContent)
+        return undefined;
     return {
         type: "reasoning",
         ...(id === undefined ? {} : { id }),

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

@@ -429,13 +429,16 @@ export declare const protocol: Protocol<{
         }[] | undefined;
         readonly error?: unknown;
         readonly usage?: {
+            readonly [x: string]: unknown;
             readonly input_tokens?: number | undefined;
             readonly output_tokens?: number | undefined;
             readonly output_tokens_details?: {
+                readonly [x: string]: unknown;
                 readonly reasoning_tokens?: number | undefined;
             } | null | undefined;
             readonly total_tokens?: number | undefined;
             readonly input_tokens_details?: {
+                readonly [x: string]: unknown;
                 readonly cached_tokens?: number | undefined;
                 readonly cache_write_tokens?: number | undefined;
             } | null | undefined;

package/dist/protocols/utils/bedrock-auth.js

@@ -15,7 +15,8 @@ import { ProviderShared } from "../shared.js";
 export const defaultChain = (options) => Effect.tryPromise({
     try: async () => {
         const { fromNodeProviderChain } = await import("@aws-sdk/credential-providers");
-        const identity = await fromNodeProviderChain(options.profile === undefined ? {} : { profile: options.profile })();
+        // ignoreCache re-reads shared config and SSO token files, so `aws sso login` takes effect without a restart.
+        const identity = await fromNodeProviderChain({ ignoreCache: true, profile: options.profile })();
         return {
             region: options.region,
             accessKeyId: identity.accessKeyId,

package/dist/protocols/utils/gateway-protocol.d.ts

@@ -0,0 +1,17 @@
+import { Effect } from "effect";
+import { Protocol } from "../../route/protocol.js";
+import { type AIError, type LLMRequest } from "../../schema/index.js";
+interface ParserState<Inner> {
+    readonly inner: Inner;
+    readonly gateway?: Record<string, unknown>;
+}
+export declare function gatewayProtocol<Body, Event, State>(protocol: Protocol<Body, string, Event, State>, input: {
+    readonly id: string;
+    readonly prepare: (request: LLMRequest) => Effect.Effect<{
+        readonly request: LLMRequest;
+        readonly body: Record<string, unknown>;
+    }, AIError>;
+}): Protocol<{
+    readonly [x: string]: unknown;
+}, string, Event, ParserState<State>>;
+export {};

package/dist/protocols/utils/gateway-protocol.js

@@ -0,0 +1,57 @@
+import { Effect, Option, Schema } from "effect";
+import { Protocol } from "../../route/protocol.js";
+import { LLMEvent, mergeJsonRecords } from "../../schema/index.js";
+import { JsonObject, lenient } from "../shared.js";
+const GatewayHolder = Schema.Struct({
+    provider_metadata: lenient(Schema.Struct({
+        gateway: lenient(JsonObject),
+    })),
+});
+const GatewayEvent = Schema.Struct({
+    ...GatewayHolder.fields,
+    response: lenient(GatewayHolder),
+    choices: lenient(Schema.Array(Schema.Struct({
+        delta: lenient(GatewayHolder),
+    }))),
+});
+const decodeGatewayEvent = Schema.decodeUnknownOption(GatewayEvent);
+function attachGatewayMetadata(events, gateway) {
+    if (!gateway || !events.some(LLMEvent.is.finish))
+        return events;
+    return events.map((event) => LLMEvent.is.finish(event) ? { ...event, providerMetadata: { ...event.providerMetadata, gateway } } : event);
+}
+export function gatewayProtocol(protocol, input) {
+    const initial = (request) => ({
+        inner: protocol.stream.initial(request),
+    });
+    const onHalt = protocol.stream.onHalt;
+    return Protocol.make({
+        id: input.id,
+        body: {
+            schema: JsonObject,
+            from: Effect.fnUntraced(function* (request) {
+                const prepared = yield* input.prepare(request);
+                const body = yield* protocol.body.from(prepared.request);
+                return { ...body, ...prepared.body };
+            }),
+        },
+        supportsEffortUpdates: protocol.supportsEffortUpdates,
+        sanitizer: protocol.sanitizer,
+        stream: {
+            event: protocol.stream.event,
+            initial,
+            step: Effect.fnUntraced(function* (state, event) {
+                const decoded = Option.getOrUndefined(decodeGatewayEvent(event));
+                const gateway = decoded
+                    ? mergeJsonRecords(state.gateway, decoded.provider_metadata?.gateway, decoded.response?.provider_metadata?.gateway, ...(decoded.choices ?? []).map((choice) => choice.delta?.provider_metadata?.gateway))
+                    : state.gateway;
+                const [inner, events] = yield* protocol.stream.step(state.inner, event);
+                return [{ inner, gateway }, attachGatewayMetadata(events, gateway)];
+            }),
+            terminal: protocol.stream.terminal,
+            onHalt: onHalt
+                ? (state) => onHalt(state.inner).pipe(Effect.map((events) => attachGatewayMetadata(events, state.gateway)))
+                : undefined,
+        },
+    });
+}

package/dist/protocols/utils/openai-options.d.ts

@@ -5,7 +5,7 @@ export declare const OpenAITextVerbosities: readonly ["low", "medium", "high"];
 export type OpenAITextVerbosity = OpenResponsesOptions.TextVerbosity;
 export declare const OpenAIResponseIncludables: readonly ["file_search_call.results", "web_search_call.results", "web_search_call.action.sources", "message.input_image.image_url", "computer_call_output.output.image_url", "code_interpreter_call.outputs", "reasoning.encrypted_content", "message.output_text.logprobs"];
 export type OpenAIResponseIncludable = OpenResponsesOptions.ResponseIncludable;
-export declare const OpenAIServiceTiers: readonly ["auto", "default", "flex", "priority", "scale"];
+export declare const OpenAIServiceTiers: readonly ["auto", "default", "flex", "priority", "scale", "fast", "ultrafast"];
 export type OpenAIServiceTier = (typeof OpenAIServiceTiers)[number] | (string & {});
 export declare const OpenAIReasoningEffort: import("effect/Schema").declare<OpenResponsesOptions.ReasoningEffort, OpenResponsesOptions.ReasoningEffort>;
 export declare const OpenAITextVerbosity: import("effect/Schema").declare<OpenResponsesOptions.TextVerbosity, OpenResponsesOptions.TextVerbosity>;

package/dist/protocols/utils/openai-options.js

@@ -4,7 +4,8 @@ export const OpenAITextVerbosities = OpenResponsesOptions.TextVerbosities;
 // Mirrors OpenAI's `ResponseIncludable` union from the official SDK. Keep this
 // in lockstep with `openai-node/src/resources/responses/responses.ts`.
 export const OpenAIResponseIncludables = OpenResponsesOptions.ResponseIncludables;
-export const OpenAIServiceTiers = [...OpenResponsesOptions.ServiceTiers, "scale"];
+// Mirrors OpenAI's `ServiceTier` union from the official SDK.
+export const OpenAIServiceTiers = [...OpenResponsesOptions.ServiceTiers, "scale", "fast", "ultrafast"];
 export const OpenAIReasoningEffort = OpenResponsesOptions.ReasoningEffort;
 export const OpenAITextVerbosity = OpenResponsesOptions.TextVerbosity;
 export const OpenAIResponseIncludable = OpenResponsesOptions.ResponseIncludableSchema;

package/dist/protocols/utils/tool-stream.d.ts

@@ -67,7 +67,7 @@ export declare const append: <K extends StreamKey>(tools: State<K>, key: K, text
 export declare const appendExisting: <K extends StreamKey>(route: string, tools: State<K>, key: K, text: string, missingToolMessage: string) => AppendOutcome<K> | AIError;
 /**
  * Finalize one pending tool call: parse the accumulated raw JSON, remove it
- * from state, and recover incomplete local arguments when needed.
+ * from state, and reject malformed local arguments without repairing them.
  * Missing keys are a no-op because some providers emit stop events for
  * non-tool content blocks.
  */

package/dist/protocols/utils/tool-stream.js

@@ -37,16 +37,16 @@ const inputDelta = (tool, text) => {
 };
 const toolCall = (route, tool, inputOverride) => {
     const raw = inputOverride ?? tool.input;
-    return parseToolInput(route, tool.name, raw).pipe(Effect.catch((error) => tool.providerExecuted
-        ? Effect.fail(error)
-        : Effect.succeed(Option.getOrElse(Option.map(parsePartialInput(raw), (input) => input ?? {}), () => ({})))), Effect.map((input) => LLMEvent.toolCall({
+    return parseToolInput(route, tool.name, raw).pipe(Effect.map((input) => LLMEvent.toolCall({
         id: tool.id,
         name: tool.name,
         namespace: tool.namespace,
         input,
         providerExecuted: tool.providerExecuted ? true : undefined,
         providerMetadata: tool.providerMetadata,
-    })));
+    })), Effect.catch((error) => tool.providerExecuted
+        ? Effect.fail(error)
+        : Effect.succeed(LLMEvent.toolInputError({ id: tool.id, name: tool.name, namespace: tool.namespace, raw }))));
 };
 const finishEvents = (tool, event) => [
     LLMEvent.toolInputEnd({
@@ -121,7 +121,7 @@ export const append = (tools, key, text) => {
 export const appendExisting = (route, tools, key, text, missingToolMessage) => append(tools, key, text) ?? eventError(route, missingToolMessage);
 /**
  * Finalize one pending tool call: parse the accumulated raw JSON, remove it
- * from state, and recover incomplete local arguments when needed.
+ * from state, and reject malformed local arguments without repairing them.
  * Missing keys are a no-op because some providers emit stop events for
  * non-tool content blocks.
  */

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

@@ -200,13 +200,16 @@ export declare const protocol: Protocol<{
         }[] | undefined;
         readonly error?: unknown;
         readonly usage?: {
+            readonly [x: string]: unknown;
             readonly input_tokens?: number | undefined;
             readonly output_tokens?: number | undefined;
             readonly output_tokens_details?: {
+                readonly [x: string]: unknown;
                 readonly reasoning_tokens?: number | undefined;
             } | null | undefined;
             readonly total_tokens?: number | undefined;
             readonly input_tokens_details?: {
+                readonly [x: string]: unknown;
                 readonly cached_tokens?: number | undefined;
                 readonly cache_write_tokens?: number | undefined;
             } | null | undefined;