@opencode/ai 0.0.0-dev-21421 → 0.0.0-dev-21430

package/dist/experimental/realtime.d.ts

@@ -7,6 +7,7 @@ export type RealtimeTransportInput = {
 } | {
     readonly type: "websocket";
 };
+export type RealtimeTransportType = RealtimeTransportInput["type"];
 export type RealtimeTransport = {
     readonly type: "webrtc";
     readonly sdp: string;
@@ -23,25 +24,83 @@ export interface RealtimeConnectInput {
     readonly session?: RealtimeSession;
     readonly transport: RealtimeTransportInput;
 }
+export declare const engines: readonly [{
+    readonly family: "gpt-live";
+    readonly model: "gpt-live-1";
+    readonly id: "openai-live";
+    readonly provider: "openai";
+    readonly transports: readonly ["webrtc"];
+}, {
+    readonly family: "gpt-realtime";
+    readonly model: "gpt-realtime-2.1";
+    readonly id: "openai-realtime";
+    readonly provider: "openai";
+    readonly transports: readonly ["webrtc", "websocket"];
+}, {
+    readonly family: "grok-voice";
+    readonly model: "grok-voice-3.0";
+    readonly id: "xai-realtime";
+    readonly provider: "xai";
+    readonly transports: readonly ["websocket"];
+}, {
+    readonly family: "gemini-3.8-live";
+    readonly model: "gemini-3.8-live";
+    readonly id: "gemini-live";
+    readonly provider: "google";
+    readonly transports: readonly ["websocket"];
+}];
 export declare const engine: (model: string) => {
     readonly family: "gpt-live";
+    readonly model: "gpt-live-1";
     readonly id: "openai-live";
     readonly provider: "openai";
+    readonly transports: readonly ["webrtc"];
 } | {
     readonly family: "gpt-realtime";
+    readonly model: "gpt-realtime-2.1";
     readonly id: "openai-realtime";
     readonly provider: "openai";
+    readonly transports: readonly ["webrtc", "websocket"];
 } | {
     readonly family: "grok-voice";
+    readonly model: "grok-voice-3.0";
     readonly id: "xai-realtime";
     readonly provider: "xai";
+    readonly transports: readonly ["websocket"];
 } | {
     readonly family: "gemini-3.8-live";
+    readonly model: "gemini-3.8-live";
     readonly id: "gemini-live";
     readonly provider: "google";
+    readonly transports: readonly ["websocket"];
 } | undefined;
 export declare const connect: (input: RealtimeConnectInput) => Effect.Effect<RealtimeTransport, AIError, import("../route/executor-service.js").RequestExecutorService>;
 export declare const Realtime: {
+    readonly engines: readonly [{
+        readonly family: "gpt-live";
+        readonly model: "gpt-live-1";
+        readonly id: "openai-live";
+        readonly provider: "openai";
+        readonly transports: readonly ["webrtc"];
+    }, {
+        readonly family: "gpt-realtime";
+        readonly model: "gpt-realtime-2.1";
+        readonly id: "openai-realtime";
+        readonly provider: "openai";
+        readonly transports: readonly ["webrtc", "websocket"];
+    }, {
+        readonly family: "grok-voice";
+        readonly model: "grok-voice-3.0";
+        readonly id: "xai-realtime";
+        readonly provider: "xai";
+        readonly transports: readonly ["websocket"];
+    }, {
+        readonly family: "gemini-3.8-live";
+        readonly model: "gemini-3.8-live";
+        readonly id: "gemini-live";
+        readonly provider: "google";
+        readonly transports: readonly ["websocket"];
+    }];
     readonly engine: typeof engine;
     readonly connect: (input: RealtimeConnectInput) => Effect.Effect<RealtimeTransport, AIError, import("../route/executor-service.js").RequestExecutorService>;
 };

package/dist/experimental/realtime.js

@@ -6,11 +6,23 @@ import { encodeJson } from "../utils/json.js";
 const OPENAI_BASE_URL = "https://api.openai.com/v1";
 const XAI_BASE_URL = "https://api.x.ai/v1";
 const GOOGLE_BASE_URL = "https://generativelanguage.googleapis.com/v1beta";
-const engines = [
-    { family: "gpt-live", id: "openai-live", provider: "openai" },
-    { family: "gpt-realtime", id: "openai-realtime", provider: "openai" },
-    { family: "grok-voice", id: "xai-realtime", provider: "xai" },
-    { family: "gemini-3.8-live", id: "gemini-live", provider: "google" },
+export const engines = [
+    { family: "gpt-live", model: "gpt-live-1", id: "openai-live", provider: "openai", transports: ["webrtc"] },
+    {
+        family: "gpt-realtime",
+        model: "gpt-realtime-2.1",
+        id: "openai-realtime",
+        provider: "openai",
+        transports: ["webrtc", "websocket"],
+    },
+    { family: "grok-voice", model: "grok-voice-3.0", id: "xai-realtime", provider: "xai", transports: ["websocket"] },
+    {
+        family: "gemini-3.8-live",
+        model: "gemini-3.8-live",
+        id: "gemini-live",
+        provider: "google",
+        transports: ["websocket"],
+    },
 ];
 // Matches the bare family name (`gpt-realtime`) and its versions (`gpt-realtime-2.1`, `gpt-realtime-mini`).
 export const engine = (model) => engines.find((item) => model === item.family || model.startsWith(`${item.family}-`));
@@ -18,11 +30,11 @@ export const connect = Effect.fn("Realtime.connect")(function* (input) {
     const resolved = engine(input.model);
     if (!resolved)
         return yield* invalidRequest(`Unsupported voice model: ${input.model}`);
+    if (!resolved.transports.some((type) => type === input.transport.type))
+        return yield* invalidRequest(`${input.model} only supports ${resolved.transports.join(", ")} transport`);
     const session = { ...input.session, model: input.model };
     switch (resolved.id) {
         case "openai-live": {
-            if (input.transport.type !== "webrtc")
-                return yield* invalidRequest("OpenAI GPT-Live only supports WebRTC transport");
             const data = yield* post(resolved.id, `${OPENAI_BASE_URL}/live/sessions`, input.apiKey, { session, transport: input.transport }, LiveSessionResponse);
             return { type: "webrtc", sdp: data.transport.sdp };
         }
@@ -39,16 +51,11 @@ export const connect = Effect.fn("Realtime.connect")(function* (input) {
             const sdp = yield* post(resolved.id, `${OPENAI_BASE_URL}/realtime/calls${query}`, input.apiKey, form, Schema.String);
             return { type: "webrtc", sdp };
         }
-        case "xai-realtime": {
-            if (input.transport.type !== "websocket")
-                return yield* invalidRequest("xAI Grok Voice only supports WebSocket transport");
+        case "xai-realtime":
             return yield* clientSecret(resolved.id, XAI_BASE_URL, input.model, input.apiKey, {
                 expires_after: { seconds: 60 },
             });
-        }
         case "gemini-live": {
-            if (input.transport.type !== "websocket")
-                return yield* invalidRequest("Google Gemini Live only supports WebSocket transport");
             const now = yield* Clock.currentTimeMillis;
             const expiresAt = now + 60_000;
             const data = yield* post(resolved.id, `${GOOGLE_BASE_URL}/auth_tokens`, input.apiKey, {
@@ -67,6 +74,7 @@ export const connect = Effect.fn("Realtime.connect")(function* (input) {
     }
 });
 export const Realtime = {
+    engines,
     engine,
     connect,
 };

package/dist/experimental.d.ts

@@ -2,4 +2,4 @@ export { EvaluationClient } from "./experimental/evaluation-client.js";
 export { BooleanAnswer, BooleanQuestion, ChoiceAnswer, ChoiceQuestion, Evaluation, EvaluationAnswer, EvaluationInput, EvaluationModel, EvaluationModelSchema, EvaluationQuestion, EvaluationRequest, EvaluationResponse, EvaluationRounding, ScoreAnswer, ScoreQuestion, } from "./experimental/evaluation.js";
 export type { AnswerFor, AnswersFor, EvaluationModelOptions, EvaluationOptions, EvaluationQuestions, EvaluationRequestFor, EvaluationRequestInput, EvaluationResponseFor, EvaluationRoute, } from "./experimental/evaluation.js";
 export { Realtime } from "./experimental/realtime.js";
-export type { RealtimeConnectInput, RealtimeSession, RealtimeTransport, RealtimeTransportInput, } from "./experimental/realtime.js";
+export type { RealtimeConnectInput, RealtimeSession, RealtimeTransport, RealtimeTransportInput, RealtimeTransportType, } from "./experimental/realtime.js";

package/dist/providers/openrouter.d.ts

@@ -88,8 +88,8 @@ export type Settings = ProviderPackage.Settings & OpenRouterProviderOptionsInput
     readonly baseURL?: string;
 };
 declare const OpenRouterBody: Schema.StructWithRest<Schema.Struct<{
-    model: Schema.String;
-    messages: Schema.$Array<Schema.toTaggedUnion<"role", readonly [Schema.Struct<{
+    readonly model: Schema.String;
+    readonly messages: Schema.$Array<Schema.toTaggedUnion<"role", readonly [Schema.Struct<{
         readonly role: Schema.Literal<"system">;
         readonly content: Schema.Union<readonly [Schema.String, Schema.$Array<Schema.Union<readonly [Schema.Struct<{
             readonly type: Schema.Literal<"text">;
@@ -170,7 +170,7 @@ declare const OpenRouterBody: Schema.StructWithRest<Schema.Struct<{
             }>>;
         }>>]>;
     }>]>>;
-    tools: Schema.optional<Schema.$Array<Schema.Struct<{
+    readonly tools: Schema.optional<Schema.$Array<Schema.Struct<{
         readonly type: Schema.tag<"function">;
         readonly function: Schema.Struct<{
             readonly name: Schema.String;
@@ -183,34 +183,41 @@ declare const OpenRouterBody: Schema.StructWithRest<Schema.Struct<{
             readonly ttl: Schema.optional<Schema.String>;
         }>>;
     }>>>;
-    tool_choice: Schema.optional<Schema.Union<readonly [Schema.Literals<readonly ["auto", "none", "required"]>, Schema.Struct<{
+    readonly tool_choice: Schema.optional<Schema.Union<readonly [Schema.Literals<readonly ["auto", "none", "required"]>, Schema.Struct<{
         readonly type: Schema.tag<"function">;
         readonly function: Schema.Struct<{
             readonly name: Schema.String;
         }>;
     }>]>>;
-    stream: Schema.Literal<true>;
-    stream_options: Schema.optional<Schema.Struct<{
+    readonly stream: Schema.Literal<true>;
+    readonly stream_options: Schema.optional<Schema.Struct<{
         readonly include_usage: Schema.Boolean;
     }>>;
-    store: Schema.optional<Schema.Boolean>;
-    prompt_cache_key: Schema.optional<Schema.String>;
-    reasoning_effort: Schema.optional<Schema.declare<import("../schema/options.js").ReasoningEffort, import("../schema/options.js").ReasoningEffort>>;
-    tool_stream: Schema.optional<Schema.Boolean>;
-    max_completion_tokens: Schema.optional<Schema.Number>;
-    max_tokens: Schema.optional<Schema.Number>;
-    temperature: Schema.optional<Schema.Number>;
-    top_p: Schema.optional<Schema.Number>;
-    frequency_penalty: Schema.optional<Schema.Number>;
-    presence_penalty: Schema.optional<Schema.Number>;
-    seed: Schema.optional<Schema.Number>;
-    stop: Schema.optional<Schema.$Array<Schema.String>>;
-}>, readonly [Schema.$Record<Schema.String, Schema.Any>]>;
+    readonly store: Schema.optional<Schema.Boolean>;
+    readonly prompt_cache_key: Schema.optional<Schema.String>;
+    readonly reasoning_effort: Schema.optional<Schema.declare<import("../schema/options.js").ReasoningEffort, import("../schema/options.js").ReasoningEffort>>;
+    readonly tool_stream: Schema.optional<Schema.Boolean>;
+    readonly max_completion_tokens: Schema.optional<Schema.Number>;
+    readonly max_tokens: Schema.optional<Schema.Number>;
+    readonly temperature: Schema.optional<Schema.Number>;
+    readonly top_p: Schema.optional<Schema.Number>;
+    readonly frequency_penalty: Schema.optional<Schema.Number>;
+    readonly presence_penalty: Schema.optional<Schema.Number>;
+    readonly seed: Schema.optional<Schema.Number>;
+    readonly stop: Schema.optional<Schema.$Array<Schema.String>>;
+    readonly models: Schema.optionalKey<Schema.middlewareDecoding<Schema.UndefinedOr<Schema.$Array<Schema.String>>, never>>;
+    readonly provider: Schema.optionalKey<Schema.middlewareDecoding<Schema.UndefinedOr<Schema.$Record<Schema.String, Schema.Unknown>>, never>>;
+    readonly plugins: Schema.optionalKey<Schema.middlewareDecoding<Schema.UndefinedOr<Schema.$Array<Schema.$Record<Schema.String, Schema.Unknown>>>, never>>;
+    readonly web_search_options: Schema.optionalKey<Schema.middlewareDecoding<Schema.UndefinedOr<Schema.$Record<Schema.String, Schema.Unknown>>, never>>;
+    readonly debug: Schema.optionalKey<Schema.middlewareDecoding<Schema.UndefinedOr<Schema.$Record<Schema.String, Schema.Unknown>>, never>>;
+    readonly user: Schema.optionalKey<Schema.middlewareDecoding<Schema.UndefinedOr<Schema.String>, never>>;
+    readonly reasoning: Schema.optionalKey<Schema.middlewareDecoding<Schema.UndefinedOr<Schema.$Record<Schema.String, Schema.Unknown>>, never>>;
+    readonly usage: Schema.optional<Schema.$Record<Schema.String, Schema.Unknown>>;
+}>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>;
 export type OpenRouterBody = Schema.Schema.Type<typeof OpenRouterBody>;
 export declare const protocol: Protocol<{
-    readonly [x: string]: any;
-    readonly model: string;
-    readonly messages: readonly ({
+    model: string;
+    messages: readonly ({
         readonly role: "system";
         readonly content: string | readonly ({
             readonly type: "text";
@@ -292,7 +299,7 @@ export declare const protocol: Protocol<{
         readonly reasoning_text?: string | undefined;
         readonly reasoning_details?: unknown;
     })[];
-    readonly tools?: readonly {
+    tools?: readonly {
         readonly type: "function";
         readonly function: {
             readonly name: string;
@@ -307,28 +314,46 @@ export declare const protocol: Protocol<{
             readonly ttl?: string | undefined;
         } | undefined;
     }[] | undefined;
-    readonly tool_choice?: "auto" | "none" | "required" | {
+    tool_choice?: "auto" | "none" | "required" | {
         readonly type: "function";
         readonly function: {
             readonly name: string;
         };
     } | undefined;
-    readonly stream: true;
-    readonly stream_options?: {
+    stream: true;
+    stream_options?: {
         readonly include_usage: boolean;
     } | undefined;
-    readonly store?: boolean | undefined;
-    readonly prompt_cache_key?: string | undefined;
-    readonly reasoning_effort?: import("../schema/options.js").ReasoningEffort | undefined;
-    readonly tool_stream?: boolean | undefined;
-    readonly max_completion_tokens?: number | undefined;
-    readonly max_tokens?: number | undefined;
-    readonly temperature?: number | undefined;
-    readonly top_p?: number | undefined;
-    readonly frequency_penalty?: number | undefined;
-    readonly presence_penalty?: number | undefined;
-    readonly seed?: number | undefined;
-    readonly stop?: readonly string[] | undefined;
+    store?: boolean | undefined;
+    prompt_cache_key?: string | undefined;
+    reasoning_effort?: import("../schema/options.js").ReasoningEffort | undefined;
+    tool_stream?: boolean | undefined;
+    max_completion_tokens?: number | undefined;
+    max_tokens?: number | undefined;
+    temperature?: number | undefined;
+    top_p?: number | undefined;
+    frequency_penalty?: number | undefined;
+    presence_penalty?: number | undefined;
+    seed?: number | undefined;
+    stop?: readonly string[] | undefined;
+    usage?: {
+        readonly [x: string]: unknown;
+    } | undefined;
+    models?: readonly string[] | undefined;
+    provider?: {
+        readonly [x: string]: unknown;
+    } | undefined;
+    plugins?: readonly {
+        readonly [x: string]: unknown;
+    }[] | undefined;
+    web_search_options?: {
+        readonly [x: string]: unknown;
+    } | undefined;
+    debug?: {
+        readonly [x: string]: unknown;
+    } | undefined;
+    user?: string | undefined;
+    reasoning?: Record<string, unknown> | undefined;
 }, string, "[DONE]" | {
     readonly [x: string]: unknown;
     readonly choices?: readonly {
@@ -403,9 +428,8 @@ export declare const protocol: Protocol<{
     } | null | undefined;
 }, OpenAIChat.ParserState>;
 export declare const route: Route<{
-    readonly [x: string]: any;
-    readonly model: string;
-    readonly messages: readonly ({
+    model: string;
+    messages: readonly ({
         readonly role: "system";
         readonly content: string | readonly ({
             readonly type: "text";
@@ -487,7 +511,7 @@ export declare const route: Route<{
         readonly reasoning_text?: string | undefined;
         readonly reasoning_details?: unknown;
     })[];
-    readonly tools?: readonly {
+    tools?: readonly {
         readonly type: "function";
         readonly function: {
             readonly name: string;
@@ -502,33 +526,50 @@ export declare const route: Route<{
             readonly ttl?: string | undefined;
         } | undefined;
     }[] | undefined;
-    readonly tool_choice?: "auto" | "none" | "required" | {
+    tool_choice?: "auto" | "none" | "required" | {
         readonly type: "function";
         readonly function: {
             readonly name: string;
         };
     } | undefined;
-    readonly stream: true;
-    readonly stream_options?: {
+    stream: true;
+    stream_options?: {
         readonly include_usage: boolean;
     } | undefined;
-    readonly store?: boolean | undefined;
-    readonly prompt_cache_key?: string | undefined;
-    readonly reasoning_effort?: import("../schema/options.js").ReasoningEffort | undefined;
-    readonly tool_stream?: boolean | undefined;
-    readonly max_completion_tokens?: number | undefined;
-    readonly max_tokens?: number | undefined;
-    readonly temperature?: number | undefined;
-    readonly top_p?: number | undefined;
-    readonly frequency_penalty?: number | undefined;
-    readonly presence_penalty?: number | undefined;
-    readonly seed?: number | undefined;
-    readonly stop?: readonly string[] | undefined;
+    store?: boolean | undefined;
+    prompt_cache_key?: string | undefined;
+    reasoning_effort?: import("../schema/options.js").ReasoningEffort | undefined;
+    tool_stream?: boolean | undefined;
+    max_completion_tokens?: number | undefined;
+    max_tokens?: number | undefined;
+    temperature?: number | undefined;
+    top_p?: number | undefined;
+    frequency_penalty?: number | undefined;
+    presence_penalty?: number | undefined;
+    seed?: number | undefined;
+    stop?: readonly string[] | undefined;
+    usage?: {
+        readonly [x: string]: unknown;
+    } | undefined;
+    models?: readonly string[] | undefined;
+    provider?: {
+        readonly [x: string]: unknown;
+    } | undefined;
+    plugins?: readonly {
+        readonly [x: string]: unknown;
+    }[] | undefined;
+    web_search_options?: {
+        readonly [x: string]: unknown;
+    } | undefined;
+    debug?: {
+        readonly [x: string]: unknown;
+    } | undefined;
+    user?: string | undefined;
+    reasoning?: Record<string, unknown> | undefined;
 }, import("../route/transport/http.js").HttpPrepared<string>, import("../route/client.js").CompactionOperations | undefined>;
 export declare const routes: Route<{
-    readonly [x: string]: any;
-    readonly model: string;
-    readonly messages: readonly ({
+    model: string;
+    messages: readonly ({
         readonly role: "system";
         readonly content: string | readonly ({
             readonly type: "text";
@@ -610,7 +651,7 @@ export declare const routes: Route<{
         readonly reasoning_text?: string | undefined;
         readonly reasoning_details?: unknown;
     })[];
-    readonly tools?: readonly {
+    tools?: readonly {
         readonly type: "function";
         readonly function: {
             readonly name: string;
@@ -625,28 +666,46 @@ export declare const routes: Route<{
             readonly ttl?: string | undefined;
         } | undefined;
     }[] | undefined;
-    readonly tool_choice?: "auto" | "none" | "required" | {
+    tool_choice?: "auto" | "none" | "required" | {
         readonly type: "function";
         readonly function: {
             readonly name: string;
         };
     } | undefined;
-    readonly stream: true;
-    readonly stream_options?: {
+    stream: true;
+    stream_options?: {
         readonly include_usage: boolean;
     } | undefined;
-    readonly store?: boolean | undefined;
-    readonly prompt_cache_key?: string | undefined;
-    readonly reasoning_effort?: import("../schema/options.js").ReasoningEffort | undefined;
-    readonly tool_stream?: boolean | undefined;
-    readonly max_completion_tokens?: number | undefined;
-    readonly max_tokens?: number | undefined;
-    readonly temperature?: number | undefined;
-    readonly top_p?: number | undefined;
-    readonly frequency_penalty?: number | undefined;
-    readonly presence_penalty?: number | undefined;
-    readonly seed?: number | undefined;
-    readonly stop?: readonly string[] | undefined;
+    store?: boolean | undefined;
+    prompt_cache_key?: string | undefined;
+    reasoning_effort?: import("../schema/options.js").ReasoningEffort | undefined;
+    tool_stream?: boolean | undefined;
+    max_completion_tokens?: number | undefined;
+    max_tokens?: number | undefined;
+    temperature?: number | undefined;
+    top_p?: number | undefined;
+    frequency_penalty?: number | undefined;
+    presence_penalty?: number | undefined;
+    seed?: number | undefined;
+    stop?: readonly string[] | undefined;
+    usage?: {
+        readonly [x: string]: unknown;
+    } | undefined;
+    models?: readonly string[] | undefined;
+    provider?: {
+        readonly [x: string]: unknown;
+    } | undefined;
+    plugins?: readonly {
+        readonly [x: string]: unknown;
+    }[] | undefined;
+    web_search_options?: {
+        readonly [x: string]: unknown;
+    } | undefined;
+    debug?: {
+        readonly [x: string]: unknown;
+    } | undefined;
+    user?: string | undefined;
+    reasoning?: Record<string, unknown> | undefined;
 }, import("../route/transport/http.js").HttpPrepared<string>, import("../route/client.js").CompactionOperations | undefined>[];
 export declare const configure: (input?: LanguageModelOptions) => {
     id: string & import("effect/Brand").Brand<"AI.ProviderID">;

package/dist/providers/openrouter.js

@@ -7,25 +7,36 @@ import { HttpOptions, ProviderID } from "../schema/index.js";
 import { SystemOne } from "../experimental/system-one.js";
 import { OpenAIChat } from "../protocols/openai-chat.js";
 import { cacheControl } from "../protocols/utils/cache.js";
-import { isRecord, ProviderShared } from "../protocols/shared.js";
+import { isRecord, JsonObject, lenient, ProviderShared } from "../protocols/shared.js";
 export const id = ProviderID.make("openrouter");
 const baseURL = "https://openrouter.ai/api/v1";
 const ADAPTER = "openrouter";
-const OpenRouterBody = Schema.StructWithRest(Schema.Struct(OpenAIChat.bodyFields), [
-    Schema.Record(Schema.String, Schema.Any),
-]);
+const Options = Schema.Struct({
+    usage: lenient(Schema.Union([Schema.Boolean, JsonObject])),
+    models: lenient(Schema.Array(Schema.String)),
+    provider: lenient(JsonObject),
+    plugins: lenient(Schema.Array(JsonObject)),
+    web_search_options: lenient(JsonObject),
+    debug: lenient(JsonObject),
+    user: lenient(Schema.String),
+    reasoning: lenient(JsonObject),
+});
+const decodeOptions = Schema.decodeUnknownSync(Options);
+const OpenRouterBody = Schema.StructWithRest(Schema.Struct({
+    ...OpenAIChat.bodyFields,
+    ...Options.fields,
+    usage: Schema.optional(JsonObject),
+}), [JsonObject]);
 export const protocol = Protocol.make({
     id: "openrouter-chat",
     body: {
         schema: OpenRouterBody,
-        from: (request) => OpenAIChat.fromRequest(request, { cacheControl: cacheControl() }).pipe(Effect.map((body) => {
-            const sourceAssistants = request.messages.filter((message) => message.role === "assistant");
-            let assistantIndex = 0;
-            const messages = body.messages.map((message) => {
+        from: (request) => OpenAIChat.fromRequest(request, {
+            cacheControl: cacheControl(),
+            assistant: (source, message) => {
                 if (message.role !== "assistant")
                     return message;
-                const source = sourceAssistants[assistantIndex++];
-                const reasoning = source?.content
+                const reasoning = source.content
                     .filter((part) => part.type === "reasoning")
                     .map((part) => part.text)
                     .join("");
@@ -37,13 +48,8 @@ export const protocol = Protocol.make({
                     reasoning: reasoning && reasoningDetails && reasoningDetails.length > 0 ? reasoning : undefined,
                     reasoning_details: reasoningDetails,
                 };
-            });
-            return {
-                ...body,
-                messages,
-                ...bodyOptions(request.providerOptions, request.generation?.maxTokens),
-            };
-        })),
+            },
+        }).pipe(Effect.map((body) => bodyOptions(body, request.providerOptions, request.generation?.maxTokens))),
     },
     stream: OpenAIChat.protocol.stream,
 });
@@ -52,25 +58,26 @@ export const protocol = Protocol.make({
 const fitReasoning = (reasoning, maxTokens) => typeof reasoning.max_tokens === "number"
     ? { ...reasoning, max_tokens: ProviderShared.fitThinkingBudget(reasoning.max_tokens, maxTokens, 1_024) }
     : reasoning;
-const bodyOptions = (input, maxTokens) => {
+const bodyOptions = (body, input, maxTokens) => {
     const openrouter = isRecord(input) ? input : {};
-    const { usage, models, provider, plugins, web_search_options, debug, user, reasoning, promptCacheKey, ...options } = openrouter;
+    const options = Object.fromEntries(Object.entries(openrouter).filter(([key]) => !(key in Options.fields) && key !== "promptCacheKey"));
+    const known = decodeOptions(openrouter);
+    const usage = openrouter.usage === undefined || known.usage === true
+        ? { include: true }
+        : known.usage === false
+            ? { include: false }
+            : known.usage;
     return {
         ...options,
-        ...(usage === undefined || usage === true
-            ? { usage: { include: true } }
-            : usage === false
-                ? { usage: { include: false } }
-                : isRecord(usage)
-                    ? { usage }
-                    : {}),
-        ...(Array.isArray(models) ? { models } : {}),
-        ...(isRecord(provider) ? { provider } : {}),
-        ...(Array.isArray(plugins) ? { plugins } : {}),
-        ...(isRecord(web_search_options) ? { web_search_options } : {}),
-        ...(isRecord(debug) ? { debug } : {}),
-        ...(typeof user === "string" ? { user } : {}),
-        ...(isRecord(reasoning) ? { reasoning: fitReasoning(reasoning, maxTokens) } : {}),
+        ...body,
+        ...(usage !== undefined ? { usage } : {}),
+        ...(known.models !== undefined ? { models: known.models } : {}),
+        ...(known.provider !== undefined ? { provider: known.provider } : {}),
+        ...(known.plugins !== undefined ? { plugins: known.plugins } : {}),
+        ...(known.web_search_options !== undefined ? { web_search_options: known.web_search_options } : {}),
+        ...(known.debug !== undefined ? { debug: known.debug } : {}),
+        ...(known.user !== undefined ? { user: known.user } : {}),
+        ...(known.reasoning !== undefined ? { reasoning: fitReasoning(known.reasoning, maxTokens) } : {}),
     };
 };
 export const route = Route.make({

package/package.json

@@ -1,6 +1,6 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
-  "version": "0.0.0-dev-21421",
+  "version": "0.0.0-dev-21430",
   "name": "@opencode/ai",
   "type": "module",
   "license": "MIT",
@@ -34,7 +34,7 @@
   "devDependencies": {
     "@clack/prompts": "1.0.0-alpha.1",
     "@effect/platform-node": "4.0.1",
-    "@opencode/http-recorder": "0.0.0-dev-21421",
+    "@opencode/http-recorder": "0.0.0-dev-21430",
     "@tsconfig/bun": "1.0.9",
     "@types/bun": "1.4.0",
     "@typescript/native": "npm:typescript@7.0.2",
@@ -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": "0.0.0-dev-21421",
+    "@opencode/schema": "0.0.0-dev-21430",
     "aws4fetch": "1.0.20",
     "effect": "4.0.1",
     "google-auth-library": "10.5.0"