@opencode/ai 0.0.0-reserved → 2.0.1

package/dist/providers/openrouter.d.ts

@@ -0,0 +1,563 @@
+import { Schema } from "effect";
+import { Route, type RouteDefaultsInput } from "../route/client.js";
+import { Protocol } from "../route/protocol.js";
+import { type ProviderAuthOption } from "../route/auth-options.js";
+import { type ModelID } from "../schema/index.js";
+import type { ProviderPackage } from "../provider-package.js";
+import { OpenAIChat } from "../protocols/openai-chat.js";
+export declare const id: string & import("effect/Brand").Brand<"AI.ProviderID">;
+type OpenRouterString<Known extends string> = Known | (string & {});
+export interface OpenRouterProviderRouting {
+    readonly [key: string]: unknown;
+    readonly order?: ReadonlyArray<string>;
+    readonly allow_fallbacks?: boolean;
+    readonly require_parameters?: boolean;
+    readonly data_collection?: OpenRouterString<"allow" | "deny">;
+    readonly only?: ReadonlyArray<string>;
+    readonly ignore?: ReadonlyArray<string>;
+    readonly quantizations?: ReadonlyArray<string>;
+    readonly sort?: OpenRouterString<"price" | "throughput" | "latency">;
+    readonly max_price?: Readonly<{
+        prompt?: number | string;
+        completion?: number | string;
+        image?: number | string;
+        audio?: number | string;
+        request?: number | string;
+    }>;
+    readonly zdr?: boolean;
+}
+export type OpenRouterPlugin = Readonly<{
+    id: "web";
+    max_results?: number;
+    search_prompt?: string;
+    engine?: OpenRouterString<"native" | "exa">;
+}> | Readonly<{
+    id: "file-parser";
+    max_files?: number;
+    pdf?: {
+        engine?: string;
+    };
+}> | Readonly<{
+    id: "moderation";
+}> | Readonly<{
+    id: "response-healing";
+}> | Readonly<{
+    id: "auto-router";
+    allowed_models?: ReadonlyArray<string>;
+}> | Readonly<{
+    id: string & {};
+    [key: string]: unknown;
+}>;
+export interface OpenRouterOptions {
+    readonly [key: string]: unknown;
+    readonly debug?: Readonly<{
+        echo_upstream_body?: boolean;
+    }>;
+    readonly models?: ReadonlyArray<string>;
+    readonly plugins?: ReadonlyArray<OpenRouterPlugin>;
+    readonly provider?: OpenRouterProviderRouting;
+    readonly reasoning?: Readonly<{
+        enabled?: boolean;
+        exclude?: boolean;
+        effort?: OpenRouterString<"none" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max">;
+        max_tokens?: number;
+    }>;
+    readonly usage?: boolean | Readonly<{
+        include: boolean;
+    }>;
+    readonly user?: string;
+    readonly web_search_options?: Readonly<{
+        max_results?: number;
+        search_prompt?: string;
+        engine?: OpenRouterString<"native" | "exa">;
+    }>;
+}
+export type OpenRouterProviderOptionsInput = OpenRouterOptions;
+export type LanguageModelOptions = Omit<RouteDefaultsInput, "providerOptions"> & ProviderAuthOption<"optional"> & {
+    readonly baseURL?: string;
+    readonly providerOptions?: OpenRouterProviderOptionsInput;
+};
+export type Settings = ProviderPackage.Settings & OpenRouterProviderOptionsInput & {
+    readonly apiKey?: string;
+    readonly baseURL?: string;
+};
+declare const OpenRouterBody: Schema.StructWithRest<Schema.Struct<{
+    model: Schema.String;
+    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">;
+            readonly text: Schema.String;
+            readonly cache_control: Schema.optional<Schema.Struct<{
+                readonly type: Schema.Literal<"ephemeral">;
+                readonly ttl: Schema.optional<Schema.String>;
+            }>>;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"image_url">;
+            readonly image_url: Schema.Struct<{
+                readonly url: Schema.String;
+            }>;
+        }>]>>]>;
+    }>, Schema.Struct<{
+        readonly role: Schema.Literal<"user">;
+        readonly content: Schema.Union<readonly [Schema.String, Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+            readonly type: Schema.Literal<"text">;
+            readonly text: Schema.String;
+            readonly cache_control: Schema.optional<Schema.Struct<{
+                readonly type: Schema.Literal<"ephemeral">;
+                readonly ttl: Schema.optional<Schema.String>;
+            }>>;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"image_url">;
+            readonly image_url: Schema.Struct<{
+                readonly url: Schema.String;
+            }>;
+        }>]>>]>;
+    }>, Schema.StructWithRest<Schema.Struct<{
+        readonly role: Schema.Literal<"assistant">;
+        readonly content: Schema.NullOr<Schema.String>;
+        readonly tool_calls: Schema.optional<Schema.$Array<Schema.Struct<{
+            readonly id: Schema.String;
+            readonly type: Schema.tag<"function">;
+            readonly function: Schema.Struct<{
+                readonly name: Schema.String;
+                readonly arguments: Schema.String;
+            }>;
+        }>>>;
+        readonly reasoning_content: Schema.optional<Schema.String>;
+        readonly reasoning: Schema.optional<Schema.String>;
+        readonly reasoning_text: Schema.optional<Schema.String>;
+        readonly reasoning_details: Schema.optional<Schema.Unknown>;
+        readonly cache_control: Schema.optional<Schema.Struct<{
+            readonly type: Schema.Literal<"ephemeral">;
+            readonly ttl: Schema.optional<Schema.String>;
+        }>>;
+    }>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>, Schema.Struct<{
+        readonly role: Schema.Literal<"tool">;
+        readonly tool_call_id: Schema.String;
+        readonly content: Schema.String;
+        readonly cache_control: Schema.optional<Schema.Struct<{
+            readonly type: Schema.Literal<"ephemeral">;
+            readonly ttl: Schema.optional<Schema.String>;
+        }>>;
+    }>]>>;
+    tools: Schema.optional<Schema.$Array<Schema.Struct<{
+        readonly type: Schema.tag<"function">;
+        readonly function: Schema.Struct<{
+            readonly name: Schema.String;
+            readonly description: Schema.String;
+            readonly parameters: Schema.$Record<Schema.String, Schema.Unknown>;
+            readonly strict: Schema.optional<Schema.Boolean>;
+        }>;
+        readonly cache_control: Schema.optional<Schema.Struct<{
+            readonly type: Schema.Literal<"ephemeral">;
+            readonly ttl: Schema.optional<Schema.String>;
+        }>>;
+    }>>>;
+    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 include_usage: Schema.Boolean;
+    }>>;
+    store: Schema.optional<Schema.Boolean>;
+    prompt_cache_key: Schema.optional<Schema.String>;
+    reasoning_effort: Schema.optional<Schema.declare<import("../protocols/utils/open-responses-options.js").ReasoningEffort, import("../protocols/utils/open-responses-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>]>;
+export type OpenRouterBody = Schema.Schema.Type<typeof OpenRouterBody>;
+export declare const protocol: Protocol<{
+    readonly [x: string]: any;
+    readonly model: string;
+    readonly messages: readonly ({
+        readonly role: "system";
+        readonly content: string | readonly ({
+            readonly type: "text";
+            readonly text: string;
+            readonly cache_control?: {
+                readonly type: "ephemeral";
+                readonly ttl?: string | undefined;
+            } | undefined;
+        } | {
+            readonly type: "image_url";
+            readonly image_url: {
+                readonly url: string;
+            };
+        })[];
+    } | {
+        readonly role: "user";
+        readonly content: string | readonly ({
+            readonly type: "text";
+            readonly text: string;
+            readonly cache_control?: {
+                readonly type: "ephemeral";
+                readonly ttl?: string | undefined;
+            } | undefined;
+        } | {
+            readonly type: "image_url";
+            readonly image_url: {
+                readonly url: string;
+            };
+        })[];
+    } | {
+        readonly [x: string]: unknown;
+        readonly content: string | null;
+        readonly role: "assistant";
+        readonly reasoning?: string | undefined;
+        readonly reasoning_content?: string | undefined;
+        readonly reasoning_text?: string | undefined;
+        readonly cache_control?: {
+            readonly type: "ephemeral";
+            readonly ttl?: string | undefined;
+        } | undefined;
+        readonly tool_calls?: readonly {
+            readonly id: string;
+            readonly type: "function";
+            readonly function: {
+                readonly name: string;
+                readonly arguments: string;
+            };
+        }[] | undefined;
+        readonly reasoning_details?: unknown;
+    } | {
+        readonly content: string;
+        readonly role: "tool";
+        readonly tool_call_id: string;
+        readonly cache_control?: {
+            readonly type: "ephemeral";
+            readonly ttl?: string | undefined;
+        } | undefined;
+    })[];
+    readonly stream: true;
+    readonly max_completion_tokens?: number | undefined;
+    readonly max_tokens?: number | undefined;
+    readonly tools?: readonly {
+        readonly function: {
+            readonly description: string;
+            readonly name: string;
+            readonly parameters: {
+                readonly [x: string]: unknown;
+            };
+            readonly strict?: boolean | undefined;
+        };
+        readonly type: "function";
+        readonly cache_control?: {
+            readonly type: "ephemeral";
+            readonly ttl?: string | undefined;
+        } | undefined;
+    }[] | undefined;
+    readonly stop?: readonly string[] | undefined;
+    readonly temperature?: number | undefined;
+    readonly seed?: number | undefined;
+    readonly tool_choice?: "required" | "auto" | "none" | {
+        readonly type: "function";
+        readonly function: {
+            readonly name: string;
+        };
+    } | undefined;
+    readonly top_p?: number | undefined;
+    readonly frequency_penalty?: number | undefined;
+    readonly presence_penalty?: number | undefined;
+    readonly prompt_cache_key?: string | undefined;
+    readonly reasoning_effort?: import("../protocols/utils/open-responses-options.js").ReasoningEffort | undefined;
+    readonly store?: boolean | undefined;
+    readonly stream_options?: {
+        readonly include_usage: boolean;
+    } | undefined;
+    readonly tool_stream?: boolean | undefined;
+}, string, "[DONE]" | {
+    readonly [x: string]: unknown;
+    readonly error?: {
+        readonly [x: string]: unknown;
+        readonly message: string;
+        readonly code?: string | number | null | undefined;
+    } | null | undefined;
+    readonly usage?: {
+        readonly [x: string]: unknown;
+        readonly cached_tokens?: number | null | undefined;
+        readonly prompt_tokens?: number | null | undefined;
+        readonly completion_tokens?: number | null | undefined;
+        readonly total_tokens?: number | null | undefined;
+        readonly prompt_tokens_details?: {
+            readonly [x: string]: unknown;
+            readonly cached_tokens?: number | null | undefined;
+            readonly cache_write_tokens?: number | null | undefined;
+        } | null | undefined;
+        readonly prompt_cache_hit_tokens?: number | null | undefined;
+        readonly completion_tokens_details?: {
+            readonly [x: string]: unknown;
+            readonly reasoning_tokens?: number | null | undefined;
+            readonly accepted_prediction_tokens?: number | null | undefined;
+            readonly rejected_prediction_tokens?: number | null | undefined;
+        } | null | undefined;
+    } | null | undefined;
+    readonly choices?: readonly {
+        readonly [x: string]: unknown;
+        readonly delta?: {
+            readonly [x: string]: unknown;
+            readonly reasoning?: string | null | undefined;
+            readonly reasoning_content?: string | null | undefined;
+            readonly reasoning_text?: string | null | undefined;
+            readonly content?: string | null | undefined;
+            readonly refusal?: string | null | undefined;
+            readonly tool_calls?: readonly {
+                readonly function?: {
+                    readonly name?: string | null | undefined;
+                    readonly arguments?: string | null | undefined;
+                } | null | undefined;
+                readonly id?: string | null | undefined;
+                readonly index?: number | null | undefined;
+            }[] | null | undefined;
+            readonly reasoning_details?: unknown;
+        } | null | undefined;
+        readonly usage?: {
+            readonly [x: string]: unknown;
+            readonly cached_tokens?: number | null | undefined;
+            readonly prompt_tokens?: number | null | undefined;
+            readonly completion_tokens?: number | null | undefined;
+            readonly total_tokens?: number | null | undefined;
+            readonly prompt_tokens_details?: {
+                readonly [x: string]: unknown;
+                readonly cached_tokens?: number | null | undefined;
+                readonly cache_write_tokens?: number | null | undefined;
+            } | null | undefined;
+            readonly prompt_cache_hit_tokens?: number | null | undefined;
+            readonly completion_tokens_details?: {
+                readonly [x: string]: unknown;
+                readonly reasoning_tokens?: number | null | undefined;
+                readonly accepted_prediction_tokens?: number | null | undefined;
+                readonly rejected_prediction_tokens?: number | null | undefined;
+            } | null | undefined;
+        } | null | undefined;
+        readonly finish_reason?: string | null | undefined;
+        readonly native_finish_reason?: string | null | undefined;
+    }[] | null | undefined;
+}, OpenAIChat.ParserState>;
+export declare const route: Route<{
+    readonly [x: string]: any;
+    readonly model: string;
+    readonly messages: readonly ({
+        readonly role: "system";
+        readonly content: string | readonly ({
+            readonly type: "text";
+            readonly text: string;
+            readonly cache_control?: {
+                readonly type: "ephemeral";
+                readonly ttl?: string | undefined;
+            } | undefined;
+        } | {
+            readonly type: "image_url";
+            readonly image_url: {
+                readonly url: string;
+            };
+        })[];
+    } | {
+        readonly role: "user";
+        readonly content: string | readonly ({
+            readonly type: "text";
+            readonly text: string;
+            readonly cache_control?: {
+                readonly type: "ephemeral";
+                readonly ttl?: string | undefined;
+            } | undefined;
+        } | {
+            readonly type: "image_url";
+            readonly image_url: {
+                readonly url: string;
+            };
+        })[];
+    } | {
+        readonly [x: string]: unknown;
+        readonly content: string | null;
+        readonly role: "assistant";
+        readonly reasoning?: string | undefined;
+        readonly reasoning_content?: string | undefined;
+        readonly reasoning_text?: string | undefined;
+        readonly cache_control?: {
+            readonly type: "ephemeral";
+            readonly ttl?: string | undefined;
+        } | undefined;
+        readonly tool_calls?: readonly {
+            readonly id: string;
+            readonly type: "function";
+            readonly function: {
+                readonly name: string;
+                readonly arguments: string;
+            };
+        }[] | undefined;
+        readonly reasoning_details?: unknown;
+    } | {
+        readonly content: string;
+        readonly role: "tool";
+        readonly tool_call_id: string;
+        readonly cache_control?: {
+            readonly type: "ephemeral";
+            readonly ttl?: string | undefined;
+        } | undefined;
+    })[];
+    readonly stream: true;
+    readonly max_completion_tokens?: number | undefined;
+    readonly max_tokens?: number | undefined;
+    readonly tools?: readonly {
+        readonly function: {
+            readonly description: string;
+            readonly name: string;
+            readonly parameters: {
+                readonly [x: string]: unknown;
+            };
+            readonly strict?: boolean | undefined;
+        };
+        readonly type: "function";
+        readonly cache_control?: {
+            readonly type: "ephemeral";
+            readonly ttl?: string | undefined;
+        } | undefined;
+    }[] | undefined;
+    readonly stop?: readonly string[] | undefined;
+    readonly temperature?: number | undefined;
+    readonly seed?: number | undefined;
+    readonly tool_choice?: "required" | "auto" | "none" | {
+        readonly type: "function";
+        readonly function: {
+            readonly name: string;
+        };
+    } | undefined;
+    readonly top_p?: number | undefined;
+    readonly frequency_penalty?: number | undefined;
+    readonly presence_penalty?: number | undefined;
+    readonly prompt_cache_key?: string | undefined;
+    readonly reasoning_effort?: import("../protocols/utils/open-responses-options.js").ReasoningEffort | undefined;
+    readonly store?: boolean | undefined;
+    readonly stream_options?: {
+        readonly include_usage: boolean;
+    } | undefined;
+    readonly tool_stream?: boolean | 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 ({
+        readonly role: "system";
+        readonly content: string | readonly ({
+            readonly type: "text";
+            readonly text: string;
+            readonly cache_control?: {
+                readonly type: "ephemeral";
+                readonly ttl?: string | undefined;
+            } | undefined;
+        } | {
+            readonly type: "image_url";
+            readonly image_url: {
+                readonly url: string;
+            };
+        })[];
+    } | {
+        readonly role: "user";
+        readonly content: string | readonly ({
+            readonly type: "text";
+            readonly text: string;
+            readonly cache_control?: {
+                readonly type: "ephemeral";
+                readonly ttl?: string | undefined;
+            } | undefined;
+        } | {
+            readonly type: "image_url";
+            readonly image_url: {
+                readonly url: string;
+            };
+        })[];
+    } | {
+        readonly [x: string]: unknown;
+        readonly content: string | null;
+        readonly role: "assistant";
+        readonly reasoning?: string | undefined;
+        readonly reasoning_content?: string | undefined;
+        readonly reasoning_text?: string | undefined;
+        readonly cache_control?: {
+            readonly type: "ephemeral";
+            readonly ttl?: string | undefined;
+        } | undefined;
+        readonly tool_calls?: readonly {
+            readonly id: string;
+            readonly type: "function";
+            readonly function: {
+                readonly name: string;
+                readonly arguments: string;
+            };
+        }[] | undefined;
+        readonly reasoning_details?: unknown;
+    } | {
+        readonly content: string;
+        readonly role: "tool";
+        readonly tool_call_id: string;
+        readonly cache_control?: {
+            readonly type: "ephemeral";
+            readonly ttl?: string | undefined;
+        } | undefined;
+    })[];
+    readonly stream: true;
+    readonly max_completion_tokens?: number | undefined;
+    readonly max_tokens?: number | undefined;
+    readonly tools?: readonly {
+        readonly function: {
+            readonly description: string;
+            readonly name: string;
+            readonly parameters: {
+                readonly [x: string]: unknown;
+            };
+            readonly strict?: boolean | undefined;
+        };
+        readonly type: "function";
+        readonly cache_control?: {
+            readonly type: "ephemeral";
+            readonly ttl?: string | undefined;
+        } | undefined;
+    }[] | undefined;
+    readonly stop?: readonly string[] | undefined;
+    readonly temperature?: number | undefined;
+    readonly seed?: number | undefined;
+    readonly tool_choice?: "required" | "auto" | "none" | {
+        readonly type: "function";
+        readonly function: {
+            readonly name: string;
+        };
+    } | undefined;
+    readonly top_p?: number | undefined;
+    readonly frequency_penalty?: number | undefined;
+    readonly presence_penalty?: number | undefined;
+    readonly prompt_cache_key?: string | undefined;
+    readonly reasoning_effort?: import("../protocols/utils/open-responses-options.js").ReasoningEffort | undefined;
+    readonly store?: boolean | undefined;
+    readonly stream_options?: {
+        readonly include_usage: boolean;
+    } | undefined;
+    readonly tool_stream?: boolean | 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">;
+    model: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<OpenRouterOptions, import("../route/client.js").CompactionOperations | undefined>;
+    configure: (input?: LanguageModelOptions) => /*elided*/ any;
+};
+export declare const provider: {
+    id: string & import("effect/Brand").Brand<"AI.ProviderID">;
+    model: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<OpenRouterOptions, import("../route/client.js").CompactionOperations | undefined>;
+    configure: (input?: LanguageModelOptions) => {
+        id: string & import("effect/Brand").Brand<"AI.ProviderID">;
+        model: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<OpenRouterOptions, import("../route/client.js").CompactionOperations | undefined>;
+        configure: /*elided*/ any;
+    };
+};
+export declare const model: ProviderPackage.Definition<Settings, OpenRouterProviderOptionsInput>["model"];
+export {};

package/dist/providers/openrouter.js

@@ -0,0 +1,114 @@
+import { Effect, Schema } from "effect";
+import { Route } from "../route/client.js";
+import { Endpoint } from "../route/endpoint.js";
+import { Protocol } from "../route/protocol.js";
+import { AuthOptions } from "../route/auth-options.js";
+import { ProviderID } from "../schema/index.js";
+import { OpenAIChat } from "../protocols/openai-chat.js";
+import { newBreakpoints, ttlBucket } from "../protocols/utils/cache.js";
+import { isRecord } 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),
+]);
+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) => {
+                if (message.role !== "assistant")
+                    return message;
+                const source = sourceAssistants[assistantIndex++];
+                const reasoning = source?.content
+                    .filter((part) => part.type === "reasoning")
+                    .map((part) => part.text)
+                    .join("");
+                const reasoningDetails = Array.isArray(message.reasoning_details) ? message.reasoning_details : undefined;
+                return {
+                    ...message,
+                    reasoning_content: undefined,
+                    reasoning_text: undefined,
+                    reasoning: reasoning && reasoningDetails && reasoningDetails.length > 0 ? reasoning : undefined,
+                    reasoning_details: reasoningDetails,
+                };
+            });
+            return {
+                ...body,
+                messages,
+                ...bodyOptions(request.providerOptions),
+            };
+        })),
+    },
+    stream: OpenAIChat.protocol.stream,
+});
+const cacheControl = () => {
+    const breakpoints = newBreakpoints(4);
+    return (cache) => {
+        if (cache === undefined || breakpoints.remaining === 0)
+            return undefined;
+        breakpoints.remaining -= 1;
+        return {
+            type: "ephemeral",
+            ...(ttlBucket(cache.ttlSeconds) === "1h" ? { ttl: "1h" } : {}),
+        };
+    };
+};
+const bodyOptions = (input) => {
+    const openrouter = isRecord(input) ? input : {};
+    const { usage, models, provider, plugins, web_search_options, debug, user, reasoning, promptCacheKey, ...options } = openrouter;
+    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 } : {}),
+    };
+};
+export const route = Route.make({
+    id: ADAPTER,
+    provider: id,
+    providerMetadataKey: "openrouter",
+    protocol,
+    endpoint: Endpoint.path("/chat/completions", { baseURL }),
+    framing: OpenAIChat.framing,
+});
+export const routes = [route];
+const configuredRoute = (input) => {
+    const { apiKey: _, auth: _auth, baseURL: endpoint, ...rest } = input;
+    return route.with({
+        ...rest,
+        endpoint: { baseURL: endpoint ?? baseURL },
+        auth: AuthOptions.bearer(input, "OPENROUTER_API_KEY"),
+    });
+};
+export const configure = (input = {}) => {
+    const route = configuredRoute(input);
+    return {
+        id,
+        model: (modelID) => route.model({ id: modelID }),
+        configure,
+    };
+};
+export const provider = configure();
+export const model = (modelID, { apiKey, baseURL, body, headers, ...providerOptions }) => configure({
+    apiKey,
+    baseURL,
+    headers,
+    http: body === undefined ? undefined : { body: { ...body } },
+    providerOptions,
+}).model(modelID);