@opencode/ai 2.0.23 → 2.0.24

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

@@ -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;

package/dist/protocols/anthropic-messages.js

@@ -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

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

@@ -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

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/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/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;

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

@@ -266,8 +266,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;
@@ -300,6 +302,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/providers/google-vertex-messages.js

@@ -26,6 +26,7 @@ const route = Route.make({
             }))),
         },
         stream: AnthropicMessages.protocol.stream,
+        supportsEffortUpdates: AnthropicMessages.protocol.supportsEffortUpdates,
     }),
     endpoint: Endpoint.path(({ request }) => `/${request.model.id}:streamRawPredict`),
     auth: Auth.none,

package/dist/providers/vercel-ai-gateway/chat.d.ts

@@ -0,0 +1,2 @@
+export { chatModel as model } from "../vercel-ai-gateway.js";
+export type { Settings } from "../vercel-ai-gateway.js";

package/dist/providers/vercel-ai-gateway/chat.js

@@ -0,0 +1 @@
+export { chatModel as model } from "../vercel-ai-gateway.js";

package/dist/providers/vercel-ai-gateway/messages.d.ts

@@ -0,0 +1,2 @@
+export { messagesModel as model } from "../vercel-ai-gateway.js";
+export type { Settings } from "../vercel-ai-gateway.js";

package/dist/providers/vercel-ai-gateway/messages.js

@@ -0,0 +1 @@
+export { messagesModel as model } from "../vercel-ai-gateway.js";

package/dist/providers/vercel-ai-gateway/responses.d.ts

@@ -0,0 +1,2 @@
+export { responsesModel as model } from "../vercel-ai-gateway.js";
+export type { Settings } from "../vercel-ai-gateway.js";

package/dist/providers/vercel-ai-gateway/responses.js

@@ -0,0 +1 @@
+export { responsesModel as model } from "../vercel-ai-gateway.js";

package/dist/providers/vercel-ai-gateway.d.ts

@@ -1,22 +1,89 @@
 import { EvaluationModel } from "../experimental/evaluation.js";
+import { AnthropicMessages } from "../protocols/anthropic-messages.js";
+import type { ProviderPackage } from "../provider-package.js";
 import { type ProviderAuthOption } from "../route/auth-options.js";
-import { HttpOptions, ModelID } from "../schema/index.js";
+import { Route, type RouteDefaultsInput } from "../route/client.js";
+import { ModelID } from "../schema/index.js";
+import type { OpenResponsesProviderOptionsInput } from "./open-responses-options.js";
 export declare const id: string & import("effect/Brand").Brand<"AI.ProviderID">;
-export interface EvaluationOptions {
+export interface GatewayOptions {
+    /** Service-owned options added by the Gateway without requiring an SDK update. */
     readonly [key: string]: unknown;
-    readonly gateway?: Readonly<{
+    /** Enables Gateway automatic prompt-cache breakpoint injection (`"auto"`). */
+    readonly caching?: "auto" | (string & {});
+    /** Provider slugs that are the only ones allowed to serve the request (e.g. `["anthropic", "vertex"]`). */
+    readonly only?: ReadonlyArray<string>;
+    /** Provider slugs specifying the order in which providers are tried (e.g. `["bedrock", "anthropic"]`). */
+    readonly order?: ReadonlyArray<string>;
+    /** Sort candidate providers by cost (`"cost"`), throughput (`"tps"`), or time-to-first-token (`"ttft"`). */
+    readonly sort?: "cost" | "tps" | "ttft" | (string & {});
+    /** Fallback models to try in order, or a conditional `{ model, when }` entry on evaluation requests. */
+    readonly models?: ReadonlyArray<string | Readonly<Record<string, unknown>>>;
+    /** Restrict routing to providers with zero data retention agreements. */
+    readonly zeroDataRetention?: boolean;
+    /** Restrict routing to providers that do not train on prompt data. */
+    readonly disallowPromptTraining?: boolean;
+    /**
+     * Restrict routing to provider models that satisfy every entry: capability
+     * tags (`"implicit-caching"`, `"reasoning"`, `"structured-output"`,
+     * `"tool-use"`, `"vision"`) or weight-format filters (`"quantization:fp8"`,
+     * `"!quantization:fp8"`).
+     */
+    readonly has?: ReadonlyArray<"implicit-caching" | "reasoning" | "structured-output" | "tool-use" | "vision" | `quantization:${string}` | `!quantization:${string}` | (string & {})>;
+    /** Entity identifier against which Gateway quota is tracked. */
+    readonly quotaEntityId?: string;
+    /** Unified service tier intent (`"flex"` or `"priority"`). */
+    readonly serviceTier?: "flex" | "priority" | (string & {});
+    /** End-user identifier for spend tracking and attribution. */
+    readonly user?: string;
+    /** User-specified tags for reporting and filtering usage. */
+    readonly tags?: ReadonlyArray<string>;
+    /** Request-scoped BYOK credentials keyed by provider slug, used instead of cached workspace credentials. */
+    readonly byok?: Readonly<Record<string, ReadonlyArray<Readonly<Record<string, unknown>>>>>;
+    /** Preferred inference region for upstream provider routing. */
+    readonly inferenceRegion?: string;
+    /** Per-provider timeouts in milliseconds (e.g. `{ byok: { anthropic: 3000 } }`). */
+    readonly providerTimeouts?: {
         readonly [key: string]: unknown;
-        readonly zeroDataRetention?: boolean;
-        readonly only?: ReadonlyArray<string>;
-    }>;
+        readonly byok?: Readonly<Record<string, number>>;
+    };
+}
+export type ProviderOptionsInput = OpenResponsesProviderOptionsInput & Omit<AnthropicMessages.OptionsInput, "thinking"> & {
+    /** Reasoning configuration for Messages (`thinking`) or Chat (`reasoning.enabled` + `reasoning.max_tokens`). */
+    readonly thinking?: AnthropicMessages.OptionsInput["thinking"] | {
+        readonly type: "enabled" | "adaptive" | "disabled" | (string & {});
+        readonly budgetTokens?: number;
+        readonly budget_tokens?: number;
+    };
+    /** Gateway routing, fallback, BYOK, compliance, and attribution options sent under `body.providerOptions.gateway`. */
+    readonly gateway?: GatewayOptions;
+    /** Provider-specific options forwarded under their upstream namespace in `body.providerOptions` (e.g. `{ anthropic: { ... } }`). */
+    readonly upstream?: Readonly<Record<string, Readonly<Record<string, unknown>>>>;
+    /** Responses API automatic-cache lifetime (`"5m"` or `"1h"`), sent as top-level `cache_ttl`. */
+    readonly cacheTTL?: "5m" | "1h" | (string & {});
+    /** Responses API count of stable input items to anchor for caching, sent as top-level `cache_anchor_items`. */
+    readonly cacheAnchorItems?: number;
+};
+export interface EvaluationOptions {
+    readonly [key: string]: unknown;
+    readonly gateway?: GatewayOptions;
 }
-export type Options = ProviderAuthOption<"optional"> & {
+export type Options = Omit<RouteDefaultsInput, "providerOptions"> & ProviderAuthOption<"optional"> & {
     readonly baseURL?: string;
-    readonly headers?: Record<string, string>;
-    readonly http?: HttpOptions.Input;
+    readonly providerOptions?: ProviderOptionsInput;
+};
+export type Settings = ProviderPackage.Settings & ProviderOptionsInput & {
+    readonly apiKey?: string;
 };
+export declare const routes: Route<{
+    readonly [x: string]: unknown;
+}, import("../route/transport/http.js").HttpPrepared<string>, import("../route/client.js").CompactionOperations | undefined>[];
 export declare const configure: (input?: Options) => {
     id: string & import("effect/Brand").Brand<"AI.ProviderID">;
+    model: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<ProviderOptionsInput, import("../route/client.js").CompactionOperations | undefined>;
+    messages: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<ProviderOptionsInput, import("../route/client.js").CompactionOperations | undefined>;
+    responses: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<ProviderOptionsInput, import("../route/client.js").CompactionOperations | undefined>;
+    chat: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<ProviderOptionsInput, import("../route/client.js").CompactionOperations | undefined>;
     experimental: {
         evaluation: (modelID: string | ModelID) => EvaluationModel<EvaluationOptions>;
     };
@@ -24,11 +91,19 @@ export declare const configure: (input?: Options) => {
 };
 export declare const provider: {
     id: string & import("effect/Brand").Brand<"AI.ProviderID">;
+    model: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<ProviderOptionsInput, import("../route/client.js").CompactionOperations | undefined>;
+    messages: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<ProviderOptionsInput, import("../route/client.js").CompactionOperations | undefined>;
+    responses: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<ProviderOptionsInput, import("../route/client.js").CompactionOperations | undefined>;
+    chat: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<ProviderOptionsInput, import("../route/client.js").CompactionOperations | undefined>;
     experimental: {
         evaluation: (modelID: string | ModelID) => EvaluationModel<EvaluationOptions>;
     };
     configure: (input?: Options) => {
         id: string & import("effect/Brand").Brand<"AI.ProviderID">;
+        model: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<ProviderOptionsInput, import("../route/client.js").CompactionOperations | undefined>;
+        messages: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<ProviderOptionsInput, import("../route/client.js").CompactionOperations | undefined>;
+        responses: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<ProviderOptionsInput, import("../route/client.js").CompactionOperations | undefined>;
+        chat: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<ProviderOptionsInput, import("../route/client.js").CompactionOperations | undefined>;
         experimental: {
             evaluation: (modelID: string | ModelID) => EvaluationModel<EvaluationOptions>;
         };
@@ -38,4 +113,11 @@ export declare const provider: {
 export declare const experimental: {
     evaluation: (modelID: string | ModelID) => EvaluationModel<EvaluationOptions>;
 };
+export declare const messages: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<ProviderOptionsInput, import("../route/client.js").CompactionOperations | undefined>;
+export declare const responses: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<ProviderOptionsInput, import("../route/client.js").CompactionOperations | undefined>;
+export declare const chat: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<ProviderOptionsInput, import("../route/client.js").CompactionOperations | undefined>;
+export declare const model: ProviderPackage.Definition<Settings, ProviderOptionsInput>["model"];
+export declare const messagesModel: ProviderPackage.Definition<Settings, ProviderOptionsInput>["model"];
+export declare const responsesModel: ProviderPackage.Definition<Settings, ProviderOptionsInput>["model"];
+export declare const chatModel: ProviderPackage.Definition<Settings, ProviderOptionsInput>["model"];
 export * as VercelAIGateway from "./vercel-ai-gateway.js";

package/dist/providers/vercel-ai-gateway.js

@@ -1,11 +1,111 @@
 import { Effect, Schema } from "effect";
 import { Headers, HttpClientRequest } from "effect/unstable/http";
 import { EvaluationAnswer, EvaluationInput, EvaluationModel, EvaluationQuestion, EvaluationResponse, EvaluationRounding, } from "../experimental/evaluation.js";
+import { AnthropicMessages } from "../protocols/anthropic-messages.js";
+import { OpenAIChat } from "../protocols/openai-chat.js";
+import { OpenResponses } from "../protocols/open-responses.js";
+import { optionalNull, ProviderShared } from "../protocols/shared.js";
+import { gatewayProtocol } from "../protocols/utils/gateway-protocol.js";
 import { Auth } from "../route/auth.js";
 import { AuthOptions } from "../route/auth-options.js";
-import { AIError, HttpContext, HttpOptions, InvalidProviderOutputError, InvalidRequestError, ModelID, ProviderID, ProviderMetadata, Usage, } from "../schema/index.js";
+import { Route } from "../route/client.js";
+import { Endpoint } from "../route/endpoint.js";
+import { Framing } from "../route/framing.js";
+import { AIError, HttpContext, HttpOptions, InvalidProviderOutputError, InvalidRequestError, LLMRequest, ModelID, ProviderID, ProviderMetadata, ReasoningEffort, Usage, } from "../schema/index.js";
 export const id = ProviderID.make("vercel-ai-gateway");
 const baseURL = "https://ai-gateway.vercel.sh/v1";
+const GatewayOptionsSchema = Schema.Struct({
+    gateway: Schema.optional(Schema.Record(Schema.String, Schema.Unknown)),
+    upstream: Schema.optional(Schema.Record(Schema.String, Schema.Record(Schema.String, Schema.Unknown))),
+    reasoningEffort: Schema.optional(ReasoningEffort),
+    thinking: Schema.optional(Schema.Struct({
+        type: Schema.String,
+        budgetTokens: Schema.optional(Schema.Number),
+        budget_tokens: Schema.optional(Schema.Number),
+    })),
+    cacheTTL: Schema.optional(Schema.String),
+    cacheAnchorItems: Schema.optional(Schema.Number),
+});
+const decodeOptions = ProviderShared.validateWith(Schema.decodeUnknownEffect(GatewayOptionsSchema));
+const prepare = (api) => Effect.fnUntraced(function* (request) {
+    const options = yield* decodeOptions(request.providerOptions ?? {});
+    const providerOptions = (() => {
+        if (!options.upstream && !options.gateway)
+            return undefined;
+        if (!options.gateway)
+            return options.upstream;
+        return { ...options.upstream, gateway: options.gateway };
+    })();
+    switch (api) {
+        case "messages": {
+            const effort = options.reasoningEffort;
+            if (effort === undefined)
+                return { request, body: { providerOptions } };
+            const enabled = effort !== "none";
+            const thinking = request.providerOptions?.thinking ?? { type: enabled ? "adaptive" : "disabled" };
+            const next = LLMRequest.update(request, {
+                providerOptions: {
+                    ...request.providerOptions,
+                    effort: enabled ? effort : undefined,
+                    thinking,
+                },
+            });
+            return { request: next, body: { providerOptions } };
+        }
+        case "responses":
+            return {
+                request,
+                body: {
+                    providerOptions,
+                    cache_ttl: options.cacheTTL,
+                    cache_anchor_items: options.cacheAnchorItems,
+                },
+            };
+        case "chat": {
+            if (!options.thinking)
+                return { request, body: { providerOptions } };
+            const reasoning = {
+                enabled: options.thinking.type !== "disabled",
+                max_tokens: options.thinking.budgetTokens ?? options.thinking.budget_tokens,
+            };
+            return { request, body: { providerOptions, reasoning } };
+        }
+    }
+});
+const route = (input) => Route.make({
+    id: input.id,
+    provider: id,
+    providerMetadataKey: id,
+    protocol: gatewayProtocol(input.protocol, { id: input.id, prepare: prepare(input.api) }),
+    endpoint: Endpoint.path(input.path, { baseURL }),
+    framing: input.framing,
+    headers: ({ request }) => request.promptCacheKey ? { "x-session-affinity": request.promptCacheKey } : {},
+    defaults: input.defaults,
+});
+const messagesRoute = route({
+    id: "vercel-ai-gateway-messages",
+    protocol: AnthropicMessages.protocol,
+    api: "messages",
+    path: "/messages",
+    framing: AnthropicMessages.framing,
+    defaults: { headers: { "anthropic-version": "2023-06-01" } },
+});
+const responsesRoute = route({
+    id: "vercel-ai-gateway-responses",
+    protocol: OpenResponses.protocol,
+    api: "responses",
+    path: "/responses",
+    framing: Framing.sse,
+    defaults: { providerOptions: { store: false, include: ["reasoning.encrypted_content"] } },
+});
+const chatRoute = route({
+    id: "vercel-ai-gateway-chat",
+    protocol: OpenAIChat.protocol,
+    api: "chat",
+    path: "/chat/completions",
+    framing: OpenAIChat.framing,
+});
+export const routes = [messagesRoute, responsesRoute, chatRoute];
 const Request = Schema.StructWithRest(Schema.Struct({
     model: Schema.String,
     state: EvaluationInput,
@@ -13,16 +113,39 @@ const Request = Schema.StructWithRest(Schema.Struct({
     providerOptions: Schema.optional(Schema.Record(Schema.String, Schema.Unknown)),
 }), [Schema.Record(Schema.String, Schema.Any)]);
 const Response = Schema.Struct({
-    model: Schema.optional(Schema.String),
+    model: optionalNull(Schema.String),
     answers: Schema.Record(Schema.String, EvaluationAnswer),
-    usage: Schema.optional(Schema.Struct({
-        inputTokens: Schema.optional(Schema.Number),
-        outputTokens: Schema.optional(Schema.Number),
+    usage: optionalNull(Schema.Struct({
+        inputTokens: optionalNull(Schema.Number),
+        outputTokens: optionalNull(Schema.Number),
     })),
-    rounding: Schema.optional(EvaluationRounding),
-    providerMetadata: Schema.optional(ProviderMetadata),
+    rounding: optionalNull(EvaluationRounding),
+    providerMetadata: optionalNull(ProviderMetadata),
 });
 export const configure = (input = {}) => {
+    const { apiKey: _apiKey, auth: _auth, baseURL: endpoint, ...defaults } = input;
+    const configured = {
+        ...defaults,
+        endpoint: { baseURL: endpoint ?? baseURL },
+        auth: AuthOptions.bearer(input, ["AI_GATEWAY_API_KEY", "VERCEL_OIDC_TOKEN"]),
+    };
+    const messages = (modelID) => messagesRoute.with(configured).model({
+        id: modelID,
+        // Recorded Gateway translations for non-Claude models return thinking with empty signatures.
+        compatibility: { requireSignature: modelID.startsWith("anthropic/") },
+    });
+    const responses = (modelID) => responsesRoute.with(configured).model({ id: modelID });
+    const chat = (modelID) => chatRoute
+        .with(configured)
+        .model({ id: modelID, compatibility: { reasoningField: "reasoning" } });
+    // Each family uses the API whose Gateway translation carries its reasoning state across turns.
+    const model = (modelID) => {
+        if (/^(openai\/gpt-|spacexai\/grok-)/.test(modelID))
+            return responses(modelID);
+        if (modelID.startsWith("meta/muse-"))
+            return chat(modelID);
+        return messages(modelID);
+    };
     const evaluation = (modelID) => EvaluationModel.make({
         id: modelID,
         provider: id,
@@ -39,7 +162,7 @@ export const configure = (input = {}) => {
                     questions: req.questions,
                     providerOptions: req.options,
                 }).pipe(Effect.mapError((cause) => new AIError({ reason: new InvalidRequestError({ message: cause.message, cause }) })));
-                const headers = yield* Auth.toEffect(AuthOptions.bearer(input, ["AI_GATEWAY_API_KEY", "VERCEL_OIDC_TOKEN"]))({
+                const headers = yield* Auth.toEffect(configured.auth)({
                     request: req,
                     method: "POST",
                     url: url.toString(),
@@ -59,27 +182,44 @@ export const configure = (input = {}) => {
                 });
                 const text = yield* res.text.pipe(Effect.mapError((cause) => fail("Failed to read the Vercel AI Gateway evaluation response", cause)));
                 const data = yield* Schema.decodeUnknownEffect(Schema.fromJsonString(Response))(text).pipe(Effect.mapError((cause) => fail("Vercel AI Gateway returned an invalid evaluation response", cause, text)));
+                const inputTokens = data.usage?.inputTokens ?? undefined;
+                const outputTokens = data.usage?.outputTokens ?? undefined;
+                const usage = data.usage
+                    ? new Usage({
+                        inputTokens,
+                        outputTokens,
+                        totalTokens: ProviderShared.totalTokens(inputTokens, outputTokens, undefined),
+                        providerMetadata: { gateway: data.usage },
+                    })
+                    : undefined;
                 return new EvaluationResponse({
                     model: ModelID.make(data.model ?? req.model.id),
                     answers: data.answers,
-                    usage: data.usage
-                        ? new Usage({
-                            inputTokens: data.usage.inputTokens,
-                            outputTokens: data.usage.outputTokens,
-                            totalTokens: data.usage.inputTokens === undefined && data.usage.outputTokens === undefined
-                                ? undefined
-                                : (data.usage.inputTokens ?? 0) + (data.usage.outputTokens ?? 0),
-                            providerMetadata: { gateway: data.usage },
-                        })
-                        : undefined,
-                    rounding: data.rounding,
-                    providerMetadata: data.providerMetadata,
+                    usage,
+                    rounding: data.rounding ?? undefined,
+                    providerMetadata: data.providerMetadata ?? undefined,
                 });
             }),
         },
     });
-    return { id, experimental: { evaluation }, configure };
+    return { id, model, messages, responses, chat, experimental: { evaluation }, configure };
 };
 export const provider = configure();
 export const experimental = provider.experimental;
+export const messages = provider.messages;
+export const responses = provider.responses;
+export const chat = provider.chat;
+export const model = (modelID, settings) => fromSettings(settings).model(modelID);
+export const messagesModel = (modelID, settings) => fromSettings(settings).messages(modelID);
+export const responsesModel = (modelID, settings) => fromSettings(settings).responses(modelID);
+export const chatModel = (modelID, settings) => fromSettings(settings).chat(modelID);
+function fromSettings({ apiKey, baseURL, headers, body, ...providerOptions }) {
+    return configure({
+        apiKey,
+        baseURL,
+        headers,
+        http: body === undefined ? undefined : { body: { ...body } },
+        providerOptions,
+    });
+}
 export * as VercelAIGateway from "./vercel-ai-gateway.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
-  "version": "2.0.23",
+  "version": "2.0.24",
   "name": "@opencode/ai",
   "type": "module",
   "license": "MIT",
@@ -34,7 +34,7 @@
   "devDependencies": {
     "@clack/prompts": "1.0.0-alpha.1",
     "@effect/platform-node": "4.0.0-rc.112",
-    "@opencode/http-recorder": "2.0.23",
+    "@opencode/http-recorder": "2.0.24",
     "@tsconfig/bun": "1.0.9",
     "@types/bun": "1.4.0",
     "@typescript/native-preview": "7.0.0-dev.20251207.1",
@@ -44,7 +44,7 @@
     "@aws-sdk/credential-providers": "3.1057.0",
     "@smithy/eventstream-codec": "4.2.14",
     "@smithy/util-utf8": "4.2.2",
-    "@opencode/schema": "2.0.23",
+    "@opencode/schema": "2.0.24",
     "aws4fetch": "1.0.20",
     "effect": "4.0.0-rc.112",
     "google-auth-library": "10.5.0"