@opencode/ai 2.0.22 → 2.0.24

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/dist/providers/xai.d.ts

@@ -134,9 +134,9 @@ export declare const routes: (Route<{
     readonly top_p?: number | undefined;
     readonly frequency_penalty?: number | undefined;
     readonly presence_penalty?: number | undefined;
+    readonly store?: boolean | undefined;
     readonly prompt_cache_key?: string | undefined;
     readonly reasoning_effort?: import("../schema/options.js").ReasoningEffort | undefined;
-    readonly store?: boolean | undefined;
     readonly stream_options?: {
         readonly include_usage: boolean;
     } | undefined;

package/dist/providers/zai-coding-plan.d.ts

@@ -57,6 +57,15 @@ export declare const routes: (Route<{
         readonly error?: unknown;
         readonly arguments?: string | undefined;
         readonly server_label?: string | undefined;
+    } | {
+        readonly type: "configuration_update";
+        readonly reasoning: {
+            readonly effort: import("../schema/options.js").ReasoningEffort;
+        };
+    } | {
+        readonly [x: string]: unknown;
+        readonly type: string;
+        readonly id: string;
     } | {
         readonly type: "reasoning";
         readonly summary: readonly {
@@ -144,7 +153,10 @@ export declare const routes: (Route<{
         readonly summary?: "auto" | "concise" | "detailed" | undefined;
         readonly effort?: import("../schema/options.js").ReasoningEffort | undefined;
     } | undefined;
-    readonly tools?: readonly {
+    readonly tools?: readonly ({
+        readonly [x: string]: unknown;
+        readonly type: string;
+    } | {
         readonly type: "function";
         readonly description: string;
         readonly name: string;
@@ -152,7 +164,7 @@ export declare const routes: (Route<{
             readonly [x: string]: unknown;
         };
         readonly strict?: boolean | undefined;
-    }[] | undefined;
+    })[] | undefined;
     readonly text?: {
         readonly verbosity?: import("../protocols/utils/open-responses-options.js").TextVerbosity | undefined;
     } | undefined;
@@ -172,9 +184,10 @@ export declare const routes: (Route<{
     readonly top_p?: number | undefined;
     readonly frequency_penalty?: number | undefined;
     readonly presence_penalty?: number | undefined;
+    readonly store?: boolean | undefined;
+    readonly max_output_tokens?: number | undefined;
     readonly prompt_cache_key?: string | undefined;
     readonly parallel_tool_calls?: boolean | undefined;
-    readonly store?: boolean | undefined;
     readonly include?: readonly import("../protocols/utils/open-responses-options.js").ResponseIncludable[] | undefined;
     readonly truncation?: "auto" | "disabled" | undefined;
     readonly stream_options?: {
@@ -182,7 +195,6 @@ export declare const routes: (Route<{
     } | undefined;
     readonly safety_identifier?: string | undefined;
     readonly top_logprobs?: number | undefined;
-    readonly max_output_tokens?: number | undefined;
     readonly max_tool_calls?: number | undefined;
 }, import("../route/transport/http.js").HttpPrepared<string>, import("../route/client.js").CompactionOperations | undefined> | Route<{
     readonly model: string;
@@ -303,9 +315,9 @@ export declare const routes: (Route<{
     readonly top_p?: number | undefined;
     readonly frequency_penalty?: number | undefined;
     readonly presence_penalty?: number | undefined;
+    readonly store?: boolean | undefined;
     readonly prompt_cache_key?: string | undefined;
     readonly reasoning_effort?: import("../schema/options.js").ReasoningEffort | undefined;
-    readonly store?: boolean | undefined;
     readonly stream_options?: {
         readonly include_usage: boolean;
     } | undefined;

package/dist/providers/zai.d.ts

@@ -133,9 +133,9 @@ export declare const routes: Route<{
     readonly top_p?: number | undefined;
     readonly frequency_penalty?: number | undefined;
     readonly presence_penalty?: number | undefined;
+    readonly store?: boolean | undefined;
     readonly prompt_cache_key?: string | undefined;
     readonly reasoning_effort?: import("../schema/options.js").ReasoningEffort | undefined;
-    readonly store?: boolean | undefined;
     readonly stream_options?: {
         readonly include_usage: boolean;
     } | undefined;

package/dist/route/client.js

@@ -102,7 +102,6 @@ const requireTerminalEvent = (route) => (events) => Stream.suspend(() => {
 });
 function makeFromTransport(input) {
     const protocol = input.protocol;
-    const encodeBody = Schema.encodeSync(Schema.fromJsonString(protocol.body.schema));
     const decodeEventEffect = Schema.decodeUnknownEffect(protocol.stream.event);
     const decodeEvent = (route) => (frame) => decodeEventEffect(frame).pipe(Effect.mapError((cause) => ProviderShared.eventError(input.id, `Invalid ${route} stream event`, typeof frame === "string" ? frame : ProviderShared.encodeJson(frame), cause)));
     const build = (routeInput) => {
@@ -143,7 +142,7 @@ function makeFromTransport(input) {
                 request,
                 endpoint: routeInput.endpoint,
                 auth: routeInput.auth ?? Auth.none,
-                encodeBody,
+                encodeBody: ProviderShared.encodeJson,
                 middleware: options?.http,
                 webSocket: options?.webSocket,
             }),
@@ -221,9 +220,7 @@ const prepareRequest = (request) => {
 const compile = Effect.fn("LLM.compile")(function* (request, options) {
     const resolved = prepareRequest(request);
     const route = resolved.model.route;
-    const body = yield* route.body
-        .from(resolved)
-        .pipe(Effect.flatMap(ProviderShared.validateWith(Schema.decodeUnknownEffect(route.body.schema))));
+    const body = yield* route.body.from(resolved);
     const prepared = yield* route.prepareTransport(body, resolved, options);
     return {
         request: resolved,

package/dist/route/framing.js

@@ -14,32 +14,32 @@ export const sseFraming = (bytes, events, includeDone = false) => bytes.pipe(Str
     return {
         output,
         parser: makeParser((event) => {
-            if (event._tag === "Event")
-                output.push(event);
+            if (event._tag === "Event" &&
+                (events === undefined || events.has(event.event)) &&
+                event.data.length > 0 &&
+                // Some OpenAI-compatible proxies serialize an empty flush as a bare
+                // `data: null`, between events or after `[DONE]`. No protocol has a
+                // null event, so it carries nothing and must not abort the stream.
+                event.data !== "null" &&
+                // Vertex AI partner models (e.g. `xai/grok-4.6`) send their SSE
+                // keepalive comment as `data: : keepalive` while reasoning.
+                event.data !== ": keepalive" &&
+                (event.data !== "[DONE]" || includeDone || (events !== undefined && event.event !== "message")))
+                output.push(event.data);
         }),
     };
-}, (state, chunk) => Effect.gen(function* () {
+}, (state, chunk) => {
     const error = state.parser.feed(chunk);
-    if (error)
-        return yield* new AIError({
-            reason: new InvalidProviderOutputError({
-                route: "sse",
-                message: error.message,
-                body: chunk,
-                cause: error,
-            }),
-        });
-    return [state, state.output.splice(0)];
-})), Stream.filter((event) => (events === undefined || events.has(event.event)) &&
-    event.data.length > 0 &&
-    // Some OpenAI-compatible proxies serialize an empty flush as a bare
-    // `data: null`, between events or after `[DONE]`. No protocol has a
-    // null event, so it carries nothing and must not abort the stream.
-    event.data !== "null" &&
-    // Vertex AI partner models (e.g. `xai/grok-4.6`) send their SSE
-    // keepalive comment as `data: : keepalive` while reasoning.
-    event.data !== ": keepalive" &&
-    (event.data !== "[DONE]" || includeDone || (events !== undefined && event.event !== "message"))), Stream.map((event) => event.data));
+    if (!error)
+        return Effect.succeed([state, state.output.splice(0)]);
+    const reason = new InvalidProviderOutputError({
+        route: "sse",
+        message: error.message,
+        body: chunk,
+        cause: error,
+    });
+    return Effect.fail(new AIError({ reason }));
+}));
 /** Server-Sent Events framing. Used by every JSON-streaming HTTP provider. */
 export const sse = { id: "sse", frame: sseFraming };
 /** Server-Sent Events framing that retains the conventional `[DONE]` sentinel. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
-  "version": "2.0.22",
+  "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.22",
+    "@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.22",
+    "@opencode/schema": "2.0.24",
     "aws4fetch": "1.0.20",
     "effect": "4.0.0-rc.112",
     "google-auth-library": "10.5.0"