@opencode/ai 2.0.23 → 2.0.25

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/amazon-bedrock-mantle.d.ts

@@ -257,7 +257,7 @@ export declare const routes: (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/providers/amazon-bedrock-mantle.js

@@ -30,9 +30,10 @@ const messagesRoute = Route.make({
         ...AnthropicMessages.protocol,
         // Mantle rejects mid-conversation `output_config` on Opus 5.0; support starts at 5.1+.
         supportsEffortUpdates: (request) => {
-            const override = request.model.compatibility?.supportsEffortUpdates;
-            if (override !== undefined)
-                return override;
+            if (!(AnthropicMessages.protocol.supportsEffortUpdates?.(request) ?? false))
+                return false;
+            if (request.model.compatibility?.supportsEffortUpdates !== undefined)
+                return true;
             const version = claudeVersion(request.model.id);
             return version !== undefined && (version.major > 5 || (version.major === 5 && version.minor >= 1));
         },

package/dist/providers/anthropic-compatible.d.ts

@@ -249,7 +249,7 @@ export declare const routes: import("../route/client.js").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/providers/anthropic.d.ts

@@ -234,7 +234,7 @@ export declare const routes: import("../route/client.js").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/providers/cloudflare-ai-gateway.d.ts

@@ -461,7 +461,7 @@ export declare const messagesRoute: import("../route/client.js").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 | {
@@ -856,7 +856,7 @@ export declare const routes: (import("../route/client.js").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/providers/google-vertex-messages.d.ts

@@ -247,7 +247,7 @@ export declare const routes: Route<{
             readonly prefix_mismatch_behavior?: import("../schema/options.js").OpenString<"error" | "drop_block"> | undefined;
         } | undefined;
     } | {
-        readonly type: "disabled";
+        readonly type: "disabled" | "between_tools";
     } | undefined;
     service_tier?: import("../schema/options.js").OpenString<"auto" | "standard_only"> | undefined;
     container?: string | {

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/google-vertex.js

@@ -49,7 +49,7 @@ const configuredRoute = (input, modelID) => {
             provider: id,
             message: "Google Vertex tuned models do not support Express Mode API keys",
         });
-    const location = GoogleVertexShared.location(inputLocation, "us-central1");
+    const location = GoogleVertexShared.location(inputLocation, "global");
     const project = GoogleVertexShared.project(inputProject);
     const endpoint = baseURL ??
         (apiKey

package/dist/providers/google.d.ts

@@ -170,7 +170,7 @@ export declare const configure: (input?: Config) => {
     id: string & import("effect/Brand").Brand<"AI.ProviderID">;
     model: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<Gemini.OptionsInput, import("../route/client.js").CompactionOperations | undefined>;
     interactions: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<{
-        readonly serviceTier?: import("../schema/options.js").OpenString<"standard" | "flex" | "priority"> | undefined;
+        readonly serviceTier?: import("../schema/options.js").OpenString<"standard" | "flex" | "priority" | "deferred"> | undefined;
         readonly thinkingLevel?: import("../schema/options.js").OpenString<"minimal" | "low" | "medium" | "high"> | undefined;
         readonly previousInteractionId?: string | undefined;
         readonly store?: boolean | undefined;
@@ -186,7 +186,7 @@ export declare const provider: {
     id: string & import("effect/Brand").Brand<"AI.ProviderID">;
     model: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<Gemini.OptionsInput, import("../route/client.js").CompactionOperations | undefined>;
     interactions: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<{
-        readonly serviceTier?: import("../schema/options.js").OpenString<"standard" | "flex" | "priority"> | undefined;
+        readonly serviceTier?: import("../schema/options.js").OpenString<"standard" | "flex" | "priority" | "deferred"> | undefined;
         readonly thinkingLevel?: import("../schema/options.js").OpenString<"minimal" | "low" | "medium" | "high"> | undefined;
         readonly previousInteractionId?: string | undefined;
         readonly store?: boolean | undefined;
@@ -200,7 +200,7 @@ export declare const provider: {
         id: string & import("effect/Brand").Brand<"AI.ProviderID">;
         model: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<Gemini.OptionsInput, import("../route/client.js").CompactionOperations | undefined>;
         interactions: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<{
-            readonly serviceTier?: import("../schema/options.js").OpenString<"standard" | "flex" | "priority"> | undefined;
+            readonly serviceTier?: import("../schema/options.js").OpenString<"standard" | "flex" | "priority" | "deferred"> | undefined;
             readonly thinkingLevel?: import("../schema/options.js").OpenString<"minimal" | "low" | "medium" | "high"> | undefined;
             readonly previousInteractionId?: string | undefined;
             readonly store?: boolean | undefined;
@@ -216,7 +216,7 @@ export declare const provider: {
 export declare const model: ProviderPackage.Definition<Settings, Gemini.ProviderOptionsInput>["model"];
 export declare const image: (modelID: string | ModelID) => import("../image.js").ImageModel<import("../protocols/google-images.js").GoogleImageOptions>;
 export declare const interactions: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<{
-    readonly serviceTier?: import("../schema/options.js").OpenString<"standard" | "flex" | "priority"> | undefined;
+    readonly serviceTier?: import("../schema/options.js").OpenString<"standard" | "flex" | "priority" | "deferred"> | undefined;
     readonly thinkingLevel?: import("../schema/options.js").OpenString<"minimal" | "low" | "medium" | "high"> | undefined;
     readonly previousInteractionId?: string | undefined;
     readonly store?: boolean | undefined;

package/dist/providers/meta.d.ts

@@ -573,7 +573,7 @@ export declare const routes: (Route<{
             readonly prefix_mismatch_behavior?: OpenString<"error" | "drop_block"> | undefined;
         } | undefined;
     } | {
-        readonly type: "disabled";
+        readonly type: "disabled" | "between_tools";
     } | undefined;
     readonly service_tier?: OpenString<"auto" | "standard_only"> | undefined;
     readonly container?: string | {

package/dist/providers/minimax.d.ts

@@ -260,7 +260,7 @@ export declare const routes: (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/providers/moonshot.d.ts

@@ -258,7 +258,7 @@ export declare const routes: (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/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.25",
   "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.25",
     "@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.25",
     "aws4fetch": "1.0.20",
     "effect": "4.0.0-rc.112",
     "google-auth-library": "10.5.0"