@openrouter/ai-sdk-provider 1.5.3 → 6.0.0-alpha.0

package/dist/index.d.mts

@@ -1,634 +1,390 @@
-import { LanguageModelV2, LanguageModelV2CallOptions, LanguageModelV2Content, LanguageModelV2FinishReason, LanguageModelV2Usage, LanguageModelV2CallWarning, LanguageModelV2ResponseMetadata, SharedV2Headers, LanguageModelV2StreamPart, EmbeddingModelV2, SharedV2ProviderMetadata, ProviderV2 } from '@ai-sdk/provider';
-export { LanguageModelV2, LanguageModelV2Prompt } from '@ai-sdk/provider';
-import * as models from '@openrouter/sdk/models';
-import { z } from 'zod/v4';
-import { EncodeOptions, DecodeOptions, JsonValue } from '@toon-format/toon';
-export { DecodeOptions, EncodeOptions, JsonValue } from '@toon-format/toon';
+import { LanguageModelV3, LanguageModelV3CallOptions, LanguageModelV3GenerateResult, LanguageModelV3StreamResult, EmbeddingModelV3, EmbeddingModelV3CallOptions, EmbeddingModelV3Result, ImageModelV3, ImageModelV3CallOptions, SharedV3Warning, ProviderV3 } from '@ai-sdk/provider';
 
-type OpenRouterChatModelId = string;
-type OpenRouterChatSettings = {
-    /**
-  Modify the likelihood of specified tokens appearing in the completion.
-  
-  Accepts a JSON object that maps tokens (specified by their token ID in
-  the GPT tokenizer) to an associated bias value from -100 to 100. You
-  can use this tokenizer tool to convert text to token IDs. Mathematically,
-  the bias is added to the logits generated by the model prior to sampling.
-  The exact effect will vary per model, but values between -1 and 1 should
-  decrease or increase likelihood of selection; values like -100 or 100
-  should result in a ban or exclusive selection of the relevant token.
-  
-  As an example, you can pass {"50256": -100} to prevent the <|endoftext|>
-  token from being generated.
-  */
-    logitBias?: Record<number, number>;
-    /**
-  Return the log probabilities of the tokens. Including logprobs will increase
-  the response size and can slow down response times. However, it can
-  be useful to understand better how the model is behaving.
-  
-  Setting to true will return the log probabilities of the tokens that
-  were generated.
-  
-  Setting to a number will return the log probabilities of the top n
-  tokens that were generated.
-  */
-    logprobs?: boolean | number;
-    /**
-  Whether to enable parallel function calling during tool use. Default to true.
-     */
-    parallelToolCalls?: boolean;
-    /**
-  A unique identifier representing your end-user, which can help OpenRouter to
-  monitor and detect abuse. Learn more.
-  */
-    user?: string;
-    /**
-     * Plugin configurations for enabling various capabilities
-     */
-    plugins?: Array<{
-        id: models.IdWeb;
-        max_results?: number;
-        search_prompt?: string;
-        engine?: models.Engine;
-    } | {
-        id: models.IdFileParser;
-        max_files?: number;
-        pdf?: {
-            engine?: models.PdfEngine;
-        };
-    } | {
-        id: models.IdModeration;
-    }>;
+/**
+ * OpenRouter chat language model implementing AI SDK V3 LanguageModelV3 interface.
+ *
+ * Uses the OpenRouter Responses API for both streaming and non-streaming requests.
+ */
+declare class OpenRouterChatLanguageModel implements LanguageModelV3 {
+    readonly specificationVersion: "v3";
+    readonly provider = "openrouter";
+    readonly modelId: string;
+    private readonly settings;
     /**
-     * Built-in web search options for models that support native web search
+     * Supported URL patterns by media type.
+     * OpenRouter Chat API only supports image URLs natively.
+     * PDF URLs are not supported - use PDF data URIs or the Responses API instead.
      */
-    web_search_options?: {
-        /**
-         * Maximum number of search results to include
-         */
-        max_results?: number;
-        /**
-         * Custom search prompt to guide the search query
-         */
-        search_prompt?: string;
-        /**
-         * Search engine to use for web search
-         * - "native": Use provider's built-in web search
-         * - "exa": Use Exa's search API
-         * - undefined: Native if supported, otherwise Exa
-         * @see https://openrouter.ai/docs/features/web-search
-         */
-        engine?: models.Engine;
-    };
+    readonly supportedUrls: Record<string, RegExp[]>;
+    constructor(modelId: string, settings: OpenRouterModelSettings);
+    doGenerate(options: LanguageModelV3CallOptions): Promise<LanguageModelV3GenerateResult>;
+    doStream(options: LanguageModelV3CallOptions): Promise<LanguageModelV3StreamResult>;
+}
+
+/**
+ * OpenRouter embedding model implementing AI SDK V3 EmbeddingModelV3 interface.
+ */
+declare class OpenRouterEmbeddingModel implements EmbeddingModelV3 {
+    readonly specificationVersion: "v3";
+    readonly provider = "openrouter";
+    readonly modelId: string;
+    private readonly settings;
     /**
-     * Debug options for troubleshooting API requests.
-     * Only works with streaming requests.
-     * @see https://openrouter.ai/docs/api-reference/debugging
+     * Maximum number of embeddings that can be generated in a single API call.
+     * Set to 2048 as a reasonable default for most embedding models.
      */
-    debug?: {
-        /**
-         * When true, echoes back the request body that was sent to the upstream provider.
-         * The debug data will be returned as the first chunk in the stream with a `debug.echo_upstream_body` field.
-         * Sensitive data like user IDs and base64 content will be redacted.
-         */
-        echo_upstream_body?: boolean;
-    };
+    readonly maxEmbeddingsPerCall = 2048;
     /**
-     * Provider routing preferences to control request routing behavior
+     * Whether the model supports parallel calls.
      */
-    provider?: {
-        /**
-         * List of provider slugs to try in order (e.g. ["anthropic", "openai"])
-         */
-        order?: string[];
-        /**
-         * Whether to allow backup providers when primary is unavailable (default: true)
-         */
-        allow_fallbacks?: boolean;
-        /**
-         * Only use providers that support all parameters in your request (default: false)
-         */
-        require_parameters?: boolean;
-        /**
-         * Control whether to use providers that may store data
-         */
-        data_collection?: models.DataCollection;
-        /**
-         * List of provider slugs to allow for this request
-         */
-        only?: string[];
-        /**
-         * List of provider slugs to skip for this request
-         */
-        ignore?: string[];
-        /**
-         * List of quantization levels to filter by (e.g. ["int4", "int8"])
-         */
-        quantizations?: Array<models.Quantization>;
-        /**
-         * Sort providers by price, throughput, or latency
-         */
-        sort?: models.ProviderSort;
-        /**
-         * Maximum pricing you want to pay for this request
-         */
-        max_price?: {
-            prompt?: number | string;
-            completion?: number | string;
-            image?: number | string;
-            audio?: number | string;
-            request?: number | string;
+    readonly supportsParallelCalls = true;
+    constructor(modelId: string, settings: OpenRouterModelSettings);
+    doEmbed(options: EmbeddingModelV3CallOptions): Promise<EmbeddingModelV3Result>;
+}
+
+/**
+ * OpenRouter image model implementing AI SDK V3 ImageModelV3 interface.
+ *
+ * Note: Image generation is Tier 3 functionality. The doGenerate method
+ * throws an error with guidance on tracking progress.
+ */
+declare class OpenRouterImageModel implements ImageModelV3 {
+    readonly specificationVersion: "v3";
+    readonly provider = "openrouter";
+    readonly modelId: string;
+    /**
+     * Maximum number of images that can be generated in a single API call.
+     */
+    readonly maxImagesPerCall = 1;
+    constructor(modelId: string, _settings: unknown);
+    doGenerate(_options: ImageModelV3CallOptions): Promise<{
+        images: Array<string> | Array<Uint8Array>;
+        warnings: Array<SharedV3Warning>;
+        response: {
+            timestamp: Date;
+            modelId: string;
+            headers: Record<string, string> | undefined;
         };
-        /**
-         * Whether to restrict routing to only ZDR (Zero Data Retention) endpoints.
-         * When true, only endpoints that do not retain prompts will be used.
-         */
-        zdr?: boolean;
-    };
-} & OpenRouterSharedSettings;
+    }>;
+}
 
-type OpenRouterEmbeddingModelId = string;
-type OpenRouterEmbeddingSettings = {
+/**
+ * Settings for configuring an OpenRouter provider instance.
+ *
+ * @description
+ * Configuration options passed to `createOpenRouter()` to customize the provider behavior.
+ * All settings are optional - the provider will use sensible defaults and environment
+ * variables when settings are not explicitly provided.
+ *
+ * @example
+ * ```ts
+ * import { createOpenRouter } from '@openrouter/ai-sdk-provider';
+ *
+ * const openrouter = createOpenRouter({
+ *   apiKey: process.env.OPENROUTER_API_KEY,
+ *   baseURL: 'https://openrouter.ai/api/v1',
+ *   headers: {
+ *     'X-Title': 'My App',
+ *     'HTTP-Referer': 'https://myapp.com',
+ *   },
+ * });
+ * ```
+ */
+interface OpenRouterProviderSettings {
     /**
-     * A unique identifier representing your end-user, which can help OpenRouter to
-     * monitor and detect abuse.
+     * API key for OpenRouter. If not provided, will use OPENROUTER_API_KEY env var.
      */
-    user?: string;
+    apiKey?: string;
     /**
-     * Provider routing preferences to control request routing behavior
+     * Base URL for the OpenRouter API.
+     * @default 'https://openrouter.ai/api/v1'
      */
-    provider?: {
-        /**
-         * List of provider slugs to try in order (e.g. ["openai", "voyageai"])
-         */
-        order?: string[];
-        /**
-         * Whether to allow backup providers when primary is unavailable (default: true)
-         */
-        allow_fallbacks?: boolean;
-        /**
-         * Only use providers that support all parameters in your request (default: false)
-         */
-        require_parameters?: boolean;
-        /**
-         * Control whether to use providers that may store data
-         */
-        data_collection?: 'allow' | 'deny';
-        /**
-         * List of provider slugs to allow for this request
-         */
-        only?: string[];
-        /**
-         * List of provider slugs to skip for this request
-         */
-        ignore?: string[];
-        /**
-         * Sort providers by price, throughput, or latency
-         */
-        sort?: 'price' | 'throughput' | 'latency';
-        /**
-         * Maximum pricing you want to pay for this request
-         */
-        max_price?: {
-            prompt?: number | string;
-            completion?: number | string;
-            image?: number | string;
-            audio?: number | string;
-            request?: number | string;
-        };
-    };
-} & OpenRouterSharedSettings;
-
-type OpenRouterProviderOptions = {
-    models?: string[];
+    baseURL?: string;
     /**
-     * https://openrouter.ai/docs/use-cases/reasoning-tokens
-     * One of `max_tokens` or `effort` is required.
-     * If `exclude` is true, reasoning will be removed from the response. Default is false.
+     * Base URL for the OpenRouter API (alias for baseURL).
+     * @default 'https://openrouter.ai/api/v1'
+     * @deprecated Use baseURL instead.
      */
-    reasoning?: {
-        enabled?: boolean;
-        exclude?: boolean;
-    } & ({
-        max_tokens: number;
-    } | {
-        effort: 'high' | 'medium' | 'low';
-    });
+    baseUrl?: string;
     /**
-     * A unique identifier representing your end-user, which can
-     * help OpenRouter to monitor and detect abuse.
+     * Custom headers to include in all requests.
      */
-    user?: string;
-};
-type OpenRouterSharedSettings = OpenRouterProviderOptions & {
+    headers?: Record<string, string>;
     /**
-     * @deprecated use `reasoning` instead
+     * Custom fetch implementation.
      */
-    includeReasoning?: boolean;
-    extraBody?: Record<string, unknown>;
+    fetch?: typeof globalThis.fetch;
     /**
-     * Enable usage accounting to get detailed token usage information.
-     * https://openrouter.ai/docs/use-cases/usage-accounting
+     * Extra body parameters to include in all requests.
      */
-    usage?: {
-        /**
-         * When true, includes token usage information in the response.
-         */
-        include: boolean;
-    };
-};
-/**
- * Usage accounting response
- * @see https://openrouter.ai/docs/use-cases/usage-accounting
- */
-type OpenRouterUsageAccounting = {
-    promptTokens: number;
-    promptTokensDetails?: {
-        cachedTokens: number;
-    };
-    completionTokens: number;
-    completionTokensDetails?: {
-        reasoningTokens: number;
-    };
-    totalTokens: number;
-    cost?: number;
-    costDetails?: {
-        upstreamInferenceCost: number;
-    };
-};
-
-type OpenRouterCompletionModelId = string;
-type OpenRouterCompletionSettings = {
-    /**
-  Modify the likelihood of specified tokens appearing in the completion.
-  
-  Accepts a JSON object that maps tokens (specified by their token ID in
-  the GPT tokenizer) to an associated bias value from -100 to 100. You
-  can use this tokenizer tool to convert text to token IDs. Mathematically,
-  the bias is added to the logits generated by the model prior to sampling.
-  The exact effect will vary per model, but values between -1 and 1 should
-  decrease or increase likelihood of selection; values like -100 or 100
-  should result in a ban or exclusive selection of the relevant token.
-  
-  As an example, you can pass {"50256": -100} to prevent the <|endoftext|>
-  token from being generated.
-     */
-    logitBias?: Record<number, number>;
-    /**
-  Return the log probabilities of the tokens. Including logprobs will increase
-  the response size and can slow down response times. However, it can
-  be useful to better understand how the model is behaving.
-  
-  Setting to true will return the log probabilities of the tokens that
-  were generated.
-  
-  Setting to a number will return the log probabilities of the top n
-  tokens that were generated.
-     */
-    logprobs?: boolean | number;
-    /**
-  The suffix that comes after a completion of inserted text.
-     */
-    suffix?: string;
-} & OpenRouterSharedSettings;
-
-declare enum ReasoningFormat {
-    Unknown = "unknown",
-    OpenAIResponsesV1 = "openai-responses-v1",
-    XAIResponsesV1 = "xai-responses-v1",
-    AnthropicClaudeV1 = "anthropic-claude-v1",
-    GoogleGeminiV1 = "google-gemini-v1"
-}
-
-declare enum ReasoningDetailType {
-    Summary = "reasoning.summary",
-    Encrypted = "reasoning.encrypted",
-    Text = "reasoning.text"
-}
-declare const ReasoningDetailUnionSchema: z.ZodUnion<readonly [z.ZodObject<{
-    type: z.ZodLiteral<ReasoningDetailType.Summary>;
-    summary: z.ZodString;
-    id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-    format: z.ZodOptional<z.ZodNullable<z.ZodEnum<typeof ReasoningFormat>>>;
-    index: z.ZodOptional<z.ZodNumber>;
-}, z.core.$strip>, z.ZodObject<{
-    type: z.ZodLiteral<ReasoningDetailType.Encrypted>;
-    data: z.ZodString;
-    id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-    format: z.ZodOptional<z.ZodNullable<z.ZodEnum<typeof ReasoningFormat>>>;
-    index: z.ZodOptional<z.ZodNumber>;
-}, z.core.$strip>, z.ZodObject<{
-    type: z.ZodLiteral<ReasoningDetailType.Text>;
-    text: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-    signature: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-    id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-    format: z.ZodOptional<z.ZodNullable<z.ZodEnum<typeof ReasoningFormat>>>;
-    index: z.ZodOptional<z.ZodNumber>;
-}, z.core.$strip>]>;
-type ReasoningDetailUnion = z.infer<typeof ReasoningDetailUnionSchema>;
-
-type OpenRouterChatConfig = {
-    provider: string;
-    compatibility: 'strict' | 'compatible';
-    headers: () => Record<string, string | undefined>;
-    url: (options: {
-        modelId: string;
-        path: string;
-    }) => string;
-    fetch?: typeof fetch;
     extraBody?: Record<string, unknown>;
-};
-declare class OpenRouterChatLanguageModel implements LanguageModelV2 {
-    readonly specificationVersion: "v2";
-    readonly provider = "openrouter";
-    readonly defaultObjectGenerationMode: "tool";
-    readonly modelId: OpenRouterChatModelId;
-    readonly supportsImageUrls = true;
-    readonly supportedUrls: Record<string, RegExp[]>;
-    readonly settings: OpenRouterChatSettings;
-    private readonly config;
-    constructor(modelId: OpenRouterChatModelId, settings: OpenRouterChatSettings, config: OpenRouterChatConfig);
-    private getArgs;
-    doGenerate(options: LanguageModelV2CallOptions): Promise<{
-        content: Array<LanguageModelV2Content>;
-        finishReason: LanguageModelV2FinishReason;
-        usage: LanguageModelV2Usage;
-        warnings: Array<LanguageModelV2CallWarning>;
-        providerMetadata?: {
-            openrouter: {
-                provider: string;
-                reasoning_details?: ReasoningDetailUnion[];
-                usage: OpenRouterUsageAccounting;
-            };
-        };
-        request?: {
-            body?: unknown;
-        };
-        response?: LanguageModelV2ResponseMetadata & {
-            headers?: SharedV2Headers;
-            body?: unknown;
-        };
-    }>;
-    doStream(options: LanguageModelV2CallOptions): Promise<{
-        stream: ReadableStream<LanguageModelV2StreamPart>;
-        warnings: Array<LanguageModelV2CallWarning>;
-        request?: {
-            body?: unknown;
-        };
-        response?: LanguageModelV2ResponseMetadata & {
-            headers?: SharedV2Headers;
-            body?: unknown;
-        };
-    }>;
-}
-
-type OpenRouterCompletionConfig = {
-    provider: string;
-    compatibility: 'strict' | 'compatible';
-    headers: () => Record<string, string | undefined>;
-    url: (options: {
-        modelId: string;
-        path: string;
-    }) => string;
-    fetch?: typeof fetch;
-    extraBody?: Record<string, unknown>;
-};
-declare class OpenRouterCompletionLanguageModel implements LanguageModelV2 {
-    readonly specificationVersion: "v2";
-    readonly provider = "openrouter";
-    readonly modelId: OpenRouterCompletionModelId;
-    readonly supportsImageUrls = true;
-    readonly supportedUrls: Record<string, RegExp[]>;
-    readonly defaultObjectGenerationMode: undefined;
-    readonly settings: OpenRouterCompletionSettings;
-    private readonly config;
-    constructor(modelId: OpenRouterCompletionModelId, settings: OpenRouterCompletionSettings, config: OpenRouterCompletionConfig);
-    private getArgs;
-    doGenerate(options: LanguageModelV2CallOptions): Promise<Awaited<ReturnType<LanguageModelV2['doGenerate']>>>;
-    doStream(options: LanguageModelV2CallOptions): Promise<Awaited<ReturnType<LanguageModelV2['doStream']>>>;
 }
-
-type OpenRouterEmbeddingConfig = {
-    provider: string;
-    headers: () => Record<string, string | undefined>;
-    url: (options: {
-        modelId: string;
-        path: string;
-    }) => string;
-    fetch?: typeof fetch;
-    extraBody?: Record<string, unknown>;
-};
-declare class OpenRouterEmbeddingModel implements EmbeddingModelV2<string> {
-    readonly specificationVersion: "v2";
-    readonly provider = "openrouter";
-    readonly modelId: OpenRouterEmbeddingModelId;
-    readonly settings: OpenRouterEmbeddingSettings;
-    readonly maxEmbeddingsPerCall: undefined;
-    readonly supportsParallelCalls = true;
-    private readonly config;
-    constructor(modelId: OpenRouterEmbeddingModelId, settings: OpenRouterEmbeddingSettings, config: OpenRouterEmbeddingConfig);
-    doEmbed(options: {
-        values: Array<string>;
-        abortSignal?: AbortSignal;
-        headers?: Record<string, string | undefined>;
-    }): Promise<{
-        embeddings: Array<Array<number>>;
-        usage?: {
-            tokens: number;
-        };
-        providerMetadata?: SharedV2ProviderMetadata;
-        response?: {
-            headers?: SharedV2Headers;
-            body?: unknown;
-        };
-    }>;
-}
-
-interface OpenRouterProvider extends ProviderV2 {
-    (modelId: OpenRouterChatModelId, settings?: OpenRouterCompletionSettings): OpenRouterCompletionLanguageModel;
-    (modelId: OpenRouterChatModelId, settings?: OpenRouterChatSettings): OpenRouterChatLanguageModel;
-    languageModel(modelId: OpenRouterChatModelId, settings?: OpenRouterCompletionSettings): OpenRouterCompletionLanguageModel;
-    languageModel(modelId: OpenRouterChatModelId, settings?: OpenRouterChatSettings): OpenRouterChatLanguageModel;
+/**
+ * Configuration for an OpenRouter plugin.
+ *
+ * @description
+ * Plugins extend OpenRouter functionality with features like web search, code execution,
+ * and more. Each plugin has a unique identifier and optional configuration parameters.
+ * Additional plugin-specific properties can be included as needed.
+ *
+ * @example
+ * ```ts
+ * const model = openrouter('anthropic/claude-3.5-sonnet', {
+ *   plugins: [
+ *     { id: 'web-search' },
+ *     { id: 'code-interpreter', config: { timeout: 30000 } },
+ *   ],
+ * });
+ * ```
+ */
+interface OpenRouterPluginConfig {
     /**
-  Creates an OpenRouter chat model for text generation.
+     * The plugin identifier.
      */
-    chat(modelId: OpenRouterChatModelId, settings?: OpenRouterChatSettings): OpenRouterChatLanguageModel;
+    id: string;
     /**
-  Creates an OpenRouter completion model for text generation.
+     * Plugin-specific configuration.
      */
-    completion(modelId: OpenRouterCompletionModelId, settings?: OpenRouterCompletionSettings): OpenRouterCompletionLanguageModel;
+    config?: Record<string, unknown>;
     /**
-  Creates an OpenRouter text embedding model. (AI SDK v5)
+     * Allow any additional plugin-specific properties.
      */
-    textEmbeddingModel(modelId: OpenRouterEmbeddingModelId, settings?: OpenRouterEmbeddingSettings): OpenRouterEmbeddingModel;
+    [key: string]: unknown;
+}
+/**
+ * Configuration for OpenRouter's provider routing behavior.
+ *
+ * @description
+ * Controls how OpenRouter selects and falls back between different AI providers
+ * when routing requests. Use this to specify provider preferences, enable/disable
+ * fallbacks, and require specific provider parameters.
+ *
+ * @example
+ * ```ts
+ * const model = openrouter('openai/gpt-4', {
+ *   provider: {
+ *     order: ['Azure', 'OpenAI'],
+ *     allowFallbacks: true,
+ *   },
+ * });
+ * ```
+ */
+interface OpenRouterProviderRoutingConfig {
+    /**
+     * Provider order preference.
+     */
+    order?: string[];
     /**
-  Creates an OpenRouter text embedding model. (AI SDK v4 - deprecated, use textEmbeddingModel instead)
-  @deprecated Use textEmbeddingModel instead
+     * Allow fallbacks to other providers.
      */
-    embedding(modelId: OpenRouterEmbeddingModelId, settings?: OpenRouterEmbeddingSettings): OpenRouterEmbeddingModel;
+    allowFallbacks?: boolean;
+    /**
+     * Required provider parameters.
+     */
+    requireParameters?: boolean;
 }
-interface OpenRouterProviderSettings {
+/**
+ * Model-specific options for OpenRouter requests.
+ *
+ * @description
+ * Options that can be passed when creating a model to customize its behavior.
+ * These include OpenRouter-specific features like plugins, transforms, model
+ * fallbacks, and routing configuration. Additional properties are passed through
+ * to the underlying API.
+ *
+ * @example
+ * ```ts
+ * const model = openrouter('anthropic/claude-3.5-sonnet', {
+ *   usage: { include: true },
+ *   transforms: ['middle-out'],
+ *   models: ['anthropic/claude-3-opus', 'openai/gpt-4'],  // fallbacks
+ *   provider: {
+ *     order: ['Anthropic'],
+ *     allowFallbacks: false,
+ *   },
+ * });
+ * ```
+ */
+interface OpenRouterModelOptions {
     /**
-  Base URL for the OpenRouter API calls.
-       */
-    baseURL?: string;
+     * Usage accounting configuration.
+     */
+    usage?: {
+        /**
+         * Whether to include usage information in the response.
+         */
+        include?: boolean;
+    };
     /**
-  @deprecated Use `baseURL` instead.
-       */
-    baseUrl?: string;
+     * OpenRouter plugins to enable.
+     */
+    plugins?: OpenRouterPluginConfig[];
     /**
-  API key for authenticating requests.
-       */
-    apiKey?: string;
+     * Message transforms to apply.
+     */
+    transforms?: string[];
     /**
-  Custom headers to include in the requests.
-       */
-    headers?: Record<string, string>;
+     * Fallback model IDs.
+     */
+    models?: string[];
     /**
-  OpenRouter compatibility mode. Should be set to `strict` when using the OpenRouter API,
-  and `compatible` when using 3rd party providers. In `compatible` mode, newer
-  information such as streamOptions are not being sent. Defaults to 'compatible'.
+     * Routing strategy.
      */
-    compatibility?: 'strict' | 'compatible';
+    route?: string;
     /**
-  Custom fetch implementation. You can use it as a middleware to intercept requests,
-  or to provide a custom fetch implementation for e.g. testing.
-      */
-    fetch?: typeof fetch;
+     * Provider routing configuration.
+     */
+    provider?: OpenRouterProviderRoutingConfig;
     /**
-  A JSON object to send as the request body to access OpenRouter features & upstream provider features.
-    */
-    extraBody?: Record<string, unknown>;
+     * How to handle system messages for reasoning models.
+     * - 'system': Standard system message (default)
+     * - 'developer': Convert system to developer role for reasoning models
+     * - 'remove': Strip system messages entirely
+     */
+    systemMessageMode?: 'system' | 'developer' | 'remove';
     /**
-     * Record of provider slugs to API keys for injecting into provider routing.
-     * Maps provider slugs (e.g. "anthropic", "openai") to their respective API keys.
+     * Allow any additional model-specific options.
+     * These are passed through to the API.
      */
-    api_keys?: Record<string, string>;
+    [key: string]: unknown;
 }
-/**
-Create an OpenRouter provider instance.
- */
-declare function createOpenRouter(options?: OpenRouterProviderSettings): OpenRouterProvider;
-/**
-Default OpenRouter provider instance. It uses 'strict' compatibility mode.
- */
-declare const openrouter: OpenRouterProvider;
 
 /**
-@deprecated Use `createOpenRouter` instead.
+ * OpenRouter provider interface extending the AI SDK V3 ProviderV3 interface.
+ *
+ * The provider is callable - calling it directly is equivalent to calling languageModel().
  */
-declare class OpenRouter {
+interface OpenRouterProvider extends ProviderV3 {
     /**
-  Use a different URL prefix for API calls, e.g. to use proxy servers.
-  The default prefix is `https://openrouter.ai/api/v1`.
+     * Create a language model by calling the provider directly.
      */
-    readonly baseURL: string;
+    (modelId: string, settings?: OpenRouterModelOptions): OpenRouterChatLanguageModel;
     /**
-  API key that is being sent using the `Authorization` header.
-  It defaults to the `OPENROUTER_API_KEY` environment variable.
-   */
-    readonly apiKey?: string;
+     * Create a language model.
+     */
+    languageModel(modelId: string, settings?: OpenRouterModelOptions): OpenRouterChatLanguageModel;
+    /**
+     * Create a chat model (alias for languageModel).
+     */
+    chat(modelId: string, settings?: OpenRouterModelOptions): OpenRouterChatLanguageModel;
     /**
-  Custom headers to include in the requests.
+     * Create an embedding model.
      */
-    readonly headers?: Record<string, string>;
+    embeddingModel(modelId: string, settings?: OpenRouterModelOptions): OpenRouterEmbeddingModel;
     /**
-     * Record of provider slugs to API keys for injecting into provider routing.
+     * Create a text embedding model.
+     * @deprecated Use embeddingModel instead.
      */
-    readonly api_keys?: Record<string, string>;
+    textEmbeddingModel(modelId: string, settings?: OpenRouterModelOptions): OpenRouterEmbeddingModel;
     /**
-     * Creates a new OpenRouter provider instance.
+     * Create an image model.
      */
-    constructor(options?: OpenRouterProviderSettings);
-    private get baseConfig();
-    chat(modelId: OpenRouterChatModelId, settings?: OpenRouterChatSettings): OpenRouterChatLanguageModel;
-    completion(modelId: OpenRouterCompletionModelId, settings?: OpenRouterCompletionSettings): OpenRouterCompletionLanguageModel;
-    textEmbeddingModel(modelId: OpenRouterEmbeddingModelId, settings?: OpenRouterEmbeddingSettings): OpenRouterEmbeddingModel;
+    imageModel(modelId: string, settings?: OpenRouterModelOptions): OpenRouterImageModel;
     /**
-     * @deprecated Use textEmbeddingModel instead
+     * Create an image model (alias for imageModel).
      */
-    embedding(modelId: OpenRouterEmbeddingModelId, settings?: OpenRouterEmbeddingSettings): OpenRouterEmbeddingModel;
+    image(modelId: string, settings?: OpenRouterModelOptions): OpenRouterImageModel;
+    /**
+     * Create an embedding model (alias for embeddingModel).
+     * @deprecated Use embeddingModel instead.
+     */
+    embedding(modelId: string, settings?: OpenRouterModelOptions): OpenRouterEmbeddingModel;
+}
+/**
+ * Internal settings passed to model constructors.
+ * Contains resolved API key and normalized configuration.
+ */
+interface OpenRouterModelSettings {
+    apiKey: string;
+    baseURL: string;
+    headers?: Record<string, string>;
+    fetch?: typeof globalThis.fetch;
+    extraBody?: Record<string, unknown>;
+    modelOptions?: OpenRouterModelOptions;
 }
-
 /**
- * TOON (Token-Oriented Object Notation) helper utilities for token-efficient
- * data encoding in LLM prompts.
+ * Creates an OpenRouter provider instance for the AI SDK.
  *
- * TOON achieves ~40% token reduction vs JSON for tabular data while maintaining
- * high LLM comprehension accuracy.
+ * @description
+ * Factory function that creates an OpenRouter provider compatible with the AI SDK v3 provider
+ * specification. The provider can create language models, embedding models, and image models
+ * that route requests through OpenRouter to various AI providers (OpenAI, Anthropic, Google, etc.).
  *
- * @see https://toonformat.dev
- * @see https://github.com/toon-format/toon
+ * The returned provider is callable - you can use it directly as a function to create language
+ * models, or use its methods for specific model types.
  *
- * @example
+ * @param options - Provider settings including API key, base URL, headers, and fetch implementation.
+ *   If no API key is provided, it will be loaded from the OPENROUTER_API_KEY environment variable.
+ * @returns An OpenRouter provider that can create language, embedding, and image models.
+ *
+ * @example Basic usage with environment variable
  * ```ts
- * import { encodeToon, decodeToon } from '@openrouter/ai-sdk-provider';
+ * import { createOpenRouter } from '@openrouter/ai-sdk-provider';
  *
- * // Encode data to TOON format
- * const toon = await encodeToon([
- *   { id: 1, name: 'Alice', score: 95 },
- *   { id: 2, name: 'Bob', score: 87 },
- * ]);
- * // Result: [2]{id,name,score}: 1,Alice,95 2,Bob,87
+ * // Uses OPENROUTER_API_KEY from environment
+ * const openrouter = createOpenRouter();
  *
- * // Decode TOON back to JSON
- * const data = await decodeToon(toon);
+ * const model = openrouter('anthropic/claude-3.5-sonnet');
  * ```
- */
-
-type ToonEncodeOptions = EncodeOptions;
-type ToonDecodeOptions = DecodeOptions;
-/**
- * Encodes a JavaScript value into TOON format string.
  *
- * TOON is particularly efficient for uniform arrays of objects (tabular data),
- * achieving CSV-like compactness while preserving explicit structure.
+ * @example With explicit API key
+ * ```ts
+ * import { createOpenRouter } from '@openrouter/ai-sdk-provider';
  *
- * @param value - Any JavaScript value (objects, arrays, primitives)
- * @param options - Optional encoding configuration
- * @returns Promise resolving to TOON formatted string
+ * const openrouter = createOpenRouter({
+ *   apiKey: process.env.OPENROUTER_API_KEY,
+ * });
  *
- * @example
+ * const model = openrouter('anthropic/claude-3.5-sonnet');
+ * ```
+ *
+ * @example Creating different model types
+ * ```ts
+ * const openrouter = createOpenRouter();
+ *
+ * // Language model (callable shorthand)
+ * const chat = openrouter('anthropic/claude-3.5-sonnet');
+ *
+ * // Embedding model
+ * const embeddings = openrouter.embeddingModel('openai/text-embedding-3-small');
+ *
+ * // Image model
+ * const image = openrouter.imageModel('openai/dall-e-3');
+ * ```
+ *
+ * @example Model variants
  * ```ts
- * // Simple object
- * await encodeToon({ name: 'Alice', age: 30 });
- * // name: Alice
- * // age: 30
- *
- * // Tabular array (most efficient)
- * await encodeToon([
- *   { id: 1, name: 'Alice' },
- *   { id: 2, name: 'Bob' },
- * ]);
- * // [2]{id,name}: 1,Alice 2,Bob
- *
- * // With options
- * await encodeToon(data, { indent: 4, keyFolding: 'safe' });
+ * const openrouter = createOpenRouter();
+ *
+ * // Online search variant - model has web search capabilities
+ * const online = openrouter('anthropic/claude-3.5-sonnet:online');
+ *
+ * // Nitro variant - faster inference
+ * const nitro = openrouter('anthropic/claude-3.5-sonnet:nitro');
+ *
+ * // Floor pricing variant - routes to cheapest provider
+ * const floor = openrouter('anthropic/claude-3.5-sonnet:floor');
+ *
+ * // Free tier variant
+ * const free = openrouter('meta-llama/llama-3-8b-instruct:free');
  * ```
  */
-declare function encodeToon(value: unknown, options?: ToonEncodeOptions): Promise<string>;
+declare function createOpenRouter(options?: OpenRouterProviderSettings): OpenRouterProvider;
+
+declare const VERSION = "6.0.0-alpha.0";
+
 /**
- * Decodes a TOON format string into a JavaScript value.
+ * Default OpenRouter provider instance.
  *
- * @param input - TOON formatted string
- * @param options - Optional decoding configuration
- * @returns Promise resolving to parsed JavaScript value
+ * Uses OPENROUTER_API_KEY environment variable for authentication.
  *
  * @example
  * ```ts
- * // Decode simple object
- * await decodeToon('name: Alice\nage: 30');
- * // { name: 'Alice', age: 30 }
- *
- * // Decode tabular array
- * await decodeToon('[2]{id,name}: 1,Alice 2,Bob');
- * // [{ id: 1, name: 'Alice' }, { id: 2, name: 'Bob' }]
+ * import { openrouter } from '@openrouter/ai-sdk-provider';
  *
- * // With options
- * await decodeToon(toonString, { strict: false, expandPaths: 'safe' });
+ * const model = openrouter('anthropic/claude-3.5-sonnet');
  * ```
  */
-declare function decodeToon(input: string, options?: ToonDecodeOptions): Promise<JsonValue>;
+declare const openrouter: OpenRouterProvider;
 
-export { OpenRouter, type OpenRouterChatSettings, type OpenRouterCompletionSettings, type OpenRouterEmbeddingModelId, type OpenRouterEmbeddingSettings, type OpenRouterProvider, type OpenRouterProviderOptions, type OpenRouterProviderSettings, type OpenRouterSharedSettings, type OpenRouterUsageAccounting, type ToonDecodeOptions, type ToonEncodeOptions, createOpenRouter, decodeToon, encodeToon, openrouter };
+export { type OpenRouterModelOptions, type OpenRouterPluginConfig, type OpenRouterProvider, type OpenRouterProviderRoutingConfig, type OpenRouterProviderSettings, VERSION, createOpenRouter, openrouter };