@aeye/openrouter 0.4.0 → 0.5.0

package/dist/openrouter.js

@@ -14,133 +14,158 @@
  *   `defaultParams.providers.requireParameters` explicitly (`false` disables, `true`
  *   forces regardless of strictness). See {@link OpenRouterConfig.defaultParams}.
  */
-import { detectTier } from '@aeye/ai';
-import { accumulateReasoning } from '@aeye/core';
-import { OpenAIProvider } from '@aeye/openai';
+import { detectTier, INPUT_CAPABILITIES, OUTPUT_CAPABILITIES } from '@aeye/ai';
+import { REASONING_EFFORTS, replaysTo, schemaRejection, withAllowedTools } from '@aeye/core';
+import { OpenAIProvider, ProviderError, toSystemOneQuestion } from '@aeye/openai';
 import OpenAI from 'openai';
 import { fetchModels, fetchZDRModels } from './source';
 /**
- * Convert OpenRouter parameter names to our ModelParameter format
+ * OpenRouter parameter names to our ModelParameter names
  */
-function convertSupportedParameters(openRouterParams) {
-    const paramMap = {
-        'max_tokens': 'maxTokens',
-        'temperature': 'temperature',
-        'top_p': 'topP',
-        'frequency_penalty': 'frequencyPenalty',
-        'presence_penalty': 'presencePenalty',
-        'stop': 'stop',
-        'seed': 'seed',
-        'response_format': 'responseFormat',
-        'structured_outputs': 'structuredOutput',
-        'tools': 'tools',
-        'tool_choice': 'toolChoice',
-        'logit_bias': 'logitBias',
-        'logprobs': 'logProbabilities',
-        'top_logprobs': 'logProbabilities',
-        'reasoning': 'reason',
-        'include_reasoning': 'reason',
-    };
-    const converted = new Set();
-    for (const param of openRouterParams) {
-        const mapped = paramMap[param];
-        if (mapped) {
-            converted.add(mapped);
-        }
-    }
-    return Array.from(converted);
-}
+const PARAMETERS = {
+    max_tokens: 'maxTokens',
+    max_completion_tokens: 'maxTokens',
+    temperature: 'temperature',
+    top_p: 'topP',
+    frequency_penalty: 'frequencyPenalty',
+    presence_penalty: 'presencePenalty',
+    stop: 'stop',
+    seed: 'seed',
+    response_format: 'responseFormat',
+    structured_outputs: 'structuredOutput',
+    tools: 'tools',
+    tool_choice: 'toolChoice',
+    logit_bias: 'logitBias',
+    logprobs: 'logProbabilities',
+    top_logprobs: 'logProbabilities',
+    reasoning: 'reason',
+    reasoning_effort: 'reason',
+    include_reasoning: 'reason',
+    verbosity: 'verbosity',
+};
+/**
+ * Capabilities a model has for each modality it produces: chat output, plus
+ * OpenRouter's dedicated media and embedding endpoints.
+ */
+const PRODUCES = {
+    ...OUTPUT_CAPABILITIES,
+    text: 'chat',
+    speech: 'audio',
+    transcription: 'hearing',
+    embeddings: 'embedding',
+    rerank: 'rerank',
+    decisions: 'decision',
+};
+/**
+ * Capabilities a model has for each parameter it accepts.
+ */
+const PARAMETER_CAPABILITIES = {
+    tools: 'tools',
+    tool_choice: 'tools',
+    reasoning: 'reasoning',
+    include_reasoning: 'reasoning',
+    response_format: 'json',
+    structured_outputs: 'structured',
+};
 /**
- * Detect capabilities from input/output modalities
+ * Server tool call counts in usage, by the hosted tool they belong to.
+ */
+const SERVER_TOOL_USAGE = {
+    web_search_requests: 'web_search',
+    web_fetch_requests: 'web_fetch',
+    image_generation_requests: 'image_generation',
+};
+/**
+ * Aspect ratios image models accept.
+ */
+const ASPECT_RATIOS = ['1:1', '2:3', '3:2', '3:4', '4:3', '4:5', '5:4', '9:16', '16:9', '21:9'];
+/**
+ * Models used when neither the request, the context, nor the config names one.
+ */
+const DEFAULT_MODELS = {
+    imageGenerate: 'google/gemini-2.5-flash-image',
+    imageEdit: 'google/gemini-2.5-flash-image',
+    imageAnalyze: 'openai/gpt-5.4-mini',
+    transcription: 'openai/gpt-transcribe',
+    embedding: 'openai/text-embedding-3-small',
+    rerank: 'cohere/rerank-v3.5',
+    decision: 'typesafe/jev-1.14',
+};
+/**
+ * Detect capabilities from modalities and supported parameters
  */
 function detectCapabilities(model) {
     const capabilities = new Set();
-    // Chat capability - if model outputs text
-    if (model.architecture.output_modalities.includes('text')) {
-        capabilities.add('chat');
-    }
-    // Image generation - if model outputs images
-    if (model.architecture.output_modalities.includes('image')) {
-        capabilities.add('image');
+    const add = (capability) => capability && capabilities.add(capability);
+    model.architecture.input_modalities.forEach(modality => add(INPUT_CAPABILITIES[modality]));
+    model.architecture.output_modalities.forEach(modality => add(PRODUCES[modality]));
+    model.supported_parameters.forEach(param => add(PARAMETER_CAPABILITIES[param]));
+    if (capabilities.has('chat')) {
+        capabilities.add('streaming');
     }
-    // Vision capability - if model accepts images as input
-    if (model.architecture.input_modalities.includes('image')) {
-        capabilities.add('vision');
-    }
-    // Audio/hearing capability - if model accepts audio as input
-    if (model.architecture.input_modalities.includes('audio')) {
-        capabilities.add('hearing');
-    }
-    // File handling capability
-    if (model.architecture.input_modalities.includes('file')) {
-        capabilities.add('vision'); // Files often imply document/vision capabilities
-    }
-    // Tools/function calling
-    if (model.supported_parameters.includes('tools') || model.supported_parameters.includes('tool_choice')) {
-        capabilities.add('tools');
-    }
-    // Reasoning capability
-    if (model.supported_parameters.includes('reasoning') || model.supported_parameters.includes('include_reasoning')) {
-        capabilities.add('reasoning');
-    }
-    // JSON output capability
-    if (model.supported_parameters.includes('response_format')) {
-        capabilities.add('json');
-    }
-    // Structured output capability
-    if (model.supported_parameters.includes('structured_outputs')) {
-        capabilities.add('structured');
-    }
-    // Streaming capability (most models support this)
-    capabilities.add('streaming');
-    return Array.from(capabilities);
+    return capabilities;
+}
+/**
+ * A price string as a number, or undefined when free or absent.
+ */
+function price(value) {
+    const parsed = Number(value);
+    return parsed > 0 ? parsed : undefined;
+}
+/**
+ * A per-token price string as dollars per million tokens.
+ */
+function perMillion(value) {
+    const parsed = price(value);
+    return parsed && parsed * 1_000_000;
 }
 /**
  * Convert OpenRouter model to ModelInfo with full details
  */
 export function convertOpenRouterModel(model, zdrModelIds, metrics) {
     const capabilities = detectCapabilities(model);
-    const supportedParameters = convertSupportedParameters(model.supported_parameters);
-    const tier = detectTier(model.name);
-    // Update ZDR support from ZDR endpoint
     if (zdrModelIds.has(model.id)) {
-        capabilities.push('zdr');
+        capabilities.add('zdr');
     }
-    const hasValue = (x) => {
-        return x !== undefined && x !== null && x !== '' && x !== '0';
-    };
+    const { pricing } = model;
+    const embeds = capabilities.has('embedding');
+    const supportedEfforts = model.reasoning?.supported_efforts;
     return {
         provider: 'openrouter',
         id: model.id,
         name: model.name,
-        capabilities: new Set(capabilities), // Will be serialized as array
-        tier,
+        capabilities,
+        tier: detectTier(model.name),
         pricing: {
-            text: hasValue(model.pricing.prompt) || hasValue(model.pricing.completion) ? {
-                input: hasValue(model.pricing.prompt) ? parseFloat(model.pricing.prompt) * 1_000_000 : undefined,
-                output: hasValue(model.pricing.completion) ? parseFloat(model.pricing.completion) * 1_000_000 : undefined,
-            } : undefined,
-            image: hasValue(model.pricing.image) ? {
-                input: parseFloat(model.pricing.image) * 1_000_000,
-            } : undefined,
-            reasoning: hasValue(model.pricing.internal_reasoning) ? {
-                output: parseFloat(model.pricing.internal_reasoning) * 1_000_000,
-            } : undefined,
-            perRequest: hasValue(model.pricing.request)
-                ? parseFloat(model.pricing.request)
+            text: embeds ? undefined : {
+                input: perMillion(pricing.prompt),
+                output: perMillion(pricing.completion),
+                cached: perMillion(pricing.input_cache_read),
+                cacheWrite: perMillion(pricing.input_cache_write),
+            },
+            image: price(pricing.image_token) || price(pricing.image_output)
+                ? { input: perMillion(pricing.image_token), tokens: perMillion(pricing.image_output) }
                 : undefined,
+            audio: price(pricing.audio) || price(pricing.audio_output)
+                ? { input: perMillion(pricing.audio), output: perMillion(pricing.audio_output) }
+                : undefined,
+            reasoning: price(pricing.internal_reasoning) ? { output: perMillion(pricing.internal_reasoning) } : undefined,
+            embeddings: embeds ? { cost: perMillion(pricing.prompt) } : undefined,
+            tools: price(pricing.web_search) ? { web_search: price(pricing.web_search) } : undefined,
+            perRequest: price(pricing.request),
         },
         contextWindow: model.context_length,
         maxOutputTokens: model.top_provider.max_completion_tokens ?? undefined,
         tokenizer: model.architecture.tokenizer,
-        supportedParameters: new Set(supportedParameters), // Will be serialized as array
+        supportedParameters: new Set(model.supported_parameters.flatMap(param => PARAMETERS[param] ?? [])),
+        reasoningEfforts: supportedEfforts && REASONING_EFFORTS.filter(effort => supportedEfforts.includes(effort)),
+        retiresAt: model.expiration_date?.slice(0, 10),
         // Only emit metrics for FINITE values. A scraped page value that fails to
         // parse yields NaN, which `JSON.stringify` turns into `null` — poisoning the
         // generated `ModelInfo` (whose metric fields are `number | undefined`).
         metrics: metrics && (Number.isFinite(metrics.latency) || Number.isFinite(metrics.throughput)) ? {
             timeToFirstToken: Number.isFinite(metrics.latency) ? metrics.latency : undefined,
             tokensPerSecond: Number.isFinite(metrics.throughput) ? metrics.throughput : undefined,
-            // Store uptime in metadata since it's not a standard metric
         } : undefined,
         metadata: {
             description: model.description,
@@ -148,15 +173,104 @@ export function convertOpenRouterModel(model, zdrModelIds, metrics) {
             canonicalSlug: model.canonical_slug,
             huggingFaceId: model.hugging_face_id,
             created: model.created,
+            knowledgeCutoff: model.knowledge_cutoff ?? undefined,
+            voices: model.supported_voices ?? undefined,
             uptime: Number.isFinite(metrics?.uptime) ? metrics?.uptime : undefined,
         },
     };
 }
+/**
+ * A hosted tool as an OpenRouter server tool.
+ */
+function toServerTool(tool) {
+    switch (tool.type) {
+        case 'web_search':
+            return {
+                type: 'openrouter:web_search',
+                parameters: { max_results: tool.maxResults, allowed_domains: tool.allowedDomains, excluded_domains: tool.blockedDomains },
+            };
+        case 'web_fetch':
+            return { type: 'openrouter:web_fetch' };
+        case 'image_generation':
+            return { type: 'openrouter:image_generation' };
+        default:
+            throw new ProviderError('openrouter', `The ${tool.type} hosted tool is not available on OpenRouter`);
+    }
+}
+/**
+ * The supported aspect ratio closest to a WIDTHxHEIGHT size.
+ */
+function aspectRatio(size) {
+    const [width, height] = size.split('x').map(Number);
+    const ratio = (r) => { const [w, h] = r.split(':').map(Number); return w / h; };
+    return ASPECT_RATIOS.reduce((best, r) => Math.abs(ratio(r) - width / height) < Math.abs(ratio(best) - width / height) ? r : best);
+}
+/**
+ * An answer in @aeye's shape, with score probabilities in level order.
+ */
+function toDecisionAnswer(answer) {
+    switch (answer.type) {
+        case 'noul':
+            return { type: 'predicate', probability: answer.noul };
+        case 'choice':
+            return answer;
+        case 'score':
+            return {
+                type: 'score',
+                score: answer.score,
+                probabilities: Object.entries(answer.probabilities).sort(([a], [b]) => Number(a) - Number(b)).map(([, probability]) => probability),
+                confidence: answer.confidence,
+            };
+    }
+}
+/**
+ * Images a chat model produced.
+ */
+function toImages(images) {
+    return images?.length ? images.map(image => ({ url: image.image_url.url })) : undefined;
+}
+/**
+ * Usage beyond what the OpenAI shape carries: server tool calls, and the
+ * full cost, which with BYOK is OpenRouter's fee plus the provider's bill.
+ */
+function augmentUsage(target, usage) {
+    for (const [key, calls] of Object.entries(usage.server_tool_use_details ?? {})) {
+        const tool = SERVER_TOOL_USAGE[key];
+        if (tool && calls) {
+            target.tools = { ...target.tools, [tool]: calls };
+        }
+    }
+    if (usage.cost !== undefined) {
+        target.cost = usage.cost + (usage.is_byok ? usage.cost_details?.upstream_inference_cost ?? 0 : 0);
+    }
+}
 /**
  * OpenRouter provider implementation extending base OpenAI-compatible provider
  */
 export class OpenRouterProvider extends OpenAIProvider {
     name = 'openrouter';
+    defaults = DEFAULT_MODELS;
+    /**
+     * OpenRouter is a router, not a model host: it speaks an OpenAI-shaped API
+     * but forwards each request to the upstream provider that actually serves
+     * the model, translating the tool/response schemas on the way. So the wire
+     * dialect that matters is the UPSTREAM model's, which
+     * `resolveStrictFormat` already derives from the `[family]/...` id prefix
+     * (`google/gemini-3-flash-preview` → `'google'`).
+     *
+     * The inherited default is `['openai']` — correct for api.openai.com, wrong
+     * here, and it silently forced EVERY tool schema through LENIENT no matter
+     * which family the model belonged to. LENIENT encodes `z.any()` as a
+     * self-referencing `$defs/Any`, which Gemini's function-calling grammar
+     * compiler rejects with `400 INVALID_ARGUMENT` as soon as a tool call is
+     * forced. `applySchemaDeliveryFallback` never hid this because it resolves
+     * the family itself and only covers `response_format`, not tools — which is
+     * why structured output looked family-aware while tools were not.
+     */
+    supportedStrictFamilies = new Set(['openai', 'anthropic', 'google', 'xai']);
+    // Reasoning of each converted assistant message, re-attached when the
+    // messages are assembled
+    reasoningOf = new WeakMap();
     createClient(config) {
         return new OpenAI({
             apiKey: config.apiKey,
@@ -183,28 +297,66 @@ export class OpenRouterProvider extends OpenAIProvider {
             metadata: {},
         };
     }
+    /**
+     * OpenRouter serves hosted tools and reasoning options through chat
+     * completions, so the Responses API is never needed.
+     */
+    usesResponses() {
+        return false;
+    }
+    /**
+     * OpenRouter doesn't honor `allowed_tools` (models still call the others,
+     * and some upstreams reject it), so only the allowed tools are sent.
+     */
+    buildChatParams(request, run, streaming) {
+        return super.buildChatParams(withAllowedTools(request), run, streaming);
+    }
+    /**
+     * OpenRouter reports an upstream's rejection as "Provider returned error",
+     * with the upstream's own message in `metadata.raw`.
+     */
+    rejectedSchema(request, error) {
+        const body = 'error' in error ? error.error : undefined;
+        const metadata = body && typeof body === 'object' && 'metadata' in body ? body.metadata : undefined;
+        const raw = metadata && typeof metadata === 'object' && 'raw' in metadata && typeof metadata.raw === 'string' ? metadata.raw : '';
+        return schemaRejection(request, error, `${error.message} ${raw}`);
+    }
+    /**
+     * OpenRouter strips `strict` from tools bound for Anthropic unless the
+     * request carries Anthropic's structured-outputs beta flag, so a strict tool
+     * would silently go unenforced (openrouter.ai/docs/guides/routing/provider-selection,
+     * read 2026-11-04). Other upstreams ignore the header.
+     */
+    chatHeaders(params) {
+        const strictTool = params.tools?.some(tool => tool.type === 'function' && tool.function.strict);
+        return strictTool ? { 'x-anthropic-beta': 'structured-outputs-2025-11-13' } : undefined;
+    }
     /**
      * Augment chat request with OpenRouter-specific parameters
      */
     augmentChatRequest(params, request, config) {
-        // Add reasoning if specified
+        const dp = config.defaultParams;
+        // OpenRouter takes reasoning as one object with either a token budget or
+        // an effort, not both; the effort arrives already clamped to what the
+        // model accepts
         if (request.reason) {
-            params.reasoning = {
-                enabled: true,
-                effort: request.reason.effort,
-                max_tokens: request.reason.maxTokens,
-            };
+            const { maxTokens, exclude, summary, mode, context } = request.reason;
+            const budget = maxTokens ? { max_tokens: maxTokens } : { effort: params.reasoning_effort ?? undefined };
+            params.reasoning = { enabled: true, ...budget, exclude, summary, mode, context };
         }
-        const dp = config.defaultParams;
-        // Merge provider parameters from config defaults (preserve any existing
-        // params.provider already set upstream).
+        delete params.reasoning_effort;
+        // OpenRouter ignores OpenAI's inline moderation
+        delete params.moderation;
         if (dp?.providers) {
-            const { allowFallbacks, requireParameters, dataCollection, maxPrice, ...provider } = dp.providers;
+            const { allowFallbacks, requireParameters, dataCollection, enforceDistillableText, preferredMinThroughput, preferredMaxLatency, maxPrice, ...provider } = dp.providers;
             params.provider = {
                 ...params.provider,
                 allow_fallbacks: allowFallbacks,
                 require_parameters: requireParameters,
                 data_collection: dataCollection,
+                enforce_distillable_text: enforceDistillableText,
+                preferred_min_throughput: preferredMinThroughput,
+                preferred_max_latency: preferredMaxLatency,
                 max_price: maxPrice,
                 ...provider,
             };
@@ -223,155 +375,200 @@ export class OpenRouterProvider extends OpenAIProvider {
         const isStrictStructured = params.response_format?.type === 'json_schema' &&
             params.response_format.json_schema?.strict === true;
         if (isStrictStructured && dp?.providers?.requireParameters === undefined) {
-            params.provider = {
-                ...params.provider,
-                require_parameters: true,
-            };
+            params.provider = { ...params.provider, require_parameters: true };
+        }
+        // Some upstreams serve any response format as JSON mode, which refuses a
+        // conversation that never says "json" (Alibaba for Qwen: "'messages' must
+        // contain the word 'json' in some form", even for a strict json_schema,
+        // 2026-11-04). Say it once when nothing else does.
+        const saysJson = params.messages.some(message => /json/i.test(JSON.stringify(message.content ?? '')));
+        if (params.response_format && params.response_format.type !== 'text' && !saysJson) {
+            params.messages = [{ role: 'system', content: 'Respond in JSON.' }, ...params.messages];
         }
-        if (dp?.transforms) {
-            params.transforms = dp.transforms;
+        const plugins = [...dp?.plugins ?? []];
+        if (dp?.transforms?.includes('middle-out')) {
+            plugins.push({ id: 'context-compression', engine: 'middle-out' });
         }
+        if (plugins.length) {
+            params.plugins = plugins;
+        }
+        if (dp?.fallbackModels?.length) {
+            params.models = dp.fallbackModels;
+        }
+        if (request.hostedTools?.length) {
+            params.tools = [...params.tools ?? [], ...request.hostedTools.map(toServerTool)];
+        }
+        if (request.modalities?.includes('image')) {
+            params.modalities = request.modalities;
+        }
+        params.user = request.userKey;
     }
-    /**
-     *
-     * @param expected
-     * @param response
-     */
     augmentChatResponse(expected, response, config) {
         const message = expected.choices?.[0]?.message;
-        if (message) {
-            if (message.reasoning) {
-                if (!response.reasoning) {
-                    response.reasoning = {};
-                }
-                response.reasoning.content = message.reasoning;
-            }
-            if (message.reasoning_details) {
-                if (!response.reasoning) {
-                    response.reasoning = {};
-                }
-                response.reasoning.details = message.reasoning_details;
-            }
+        if (message?.reasoning || message?.reasoning_details) {
+            response.reasoning = { content: message.reasoning, details: message.reasoning_details, provider: this.name };
         }
-        const usage = expected.usage;
-        if (usage) {
-            if (!response.usage) {
-                response.usage = {};
-            }
-            if (!response.usage.text) {
-                response.usage.text = {};
-            }
-            if (usage.completion_tokens) {
-                response.usage.text.output = usage.completion_tokens;
-            }
-            if (usage.prompt_tokens) {
-                response.usage.text.input = usage.prompt_tokens;
-            }
-            if (usage.cost) {
-                response.usage.cost = usage.cost;
-            }
+        response.images = toImages(message?.images);
+        if (expected.usage) {
+            augmentUsage(response.usage ??= {}, expected.usage);
         }
     }
     augmentChatChunk(expected, chunk, config) {
-        const usage = expected.usage;
-        if (usage) {
-            if (!chunk.usage) {
-                chunk.usage = {};
-            }
-            if (!chunk.usage.text) {
-                chunk.usage.text = {};
-            }
-            if (usage.completion_tokens) {
-                chunk.usage.text.output = usage.completion_tokens;
-            }
-            if (usage.prompt_tokens) {
-                chunk.usage.text.input = usage.prompt_tokens;
-            }
-            if (usage.cost) {
-                chunk.usage.cost = usage.cost;
-            }
-        }
         const delta = expected.choices[0]?.delta;
         if (delta?.reasoning || delta?.reasoning_details?.length) {
-            chunk.reasoning = accumulateReasoning(chunk.reasoning, {
-                content: delta.reasoning,
-                details: delta.reasoning_details,
-            });
+            chunk.reasoning = { content: delta.reasoning, details: delta.reasoning_details, provider: this.name };
+        }
+        chunk.images = toImages(delta?.images);
+        if (expected.usage) {
+            augmentUsage(chunk.usage ??= {}, expected.usage);
         }
     }
-    augmentChatMessage(chatMessage, message, config) {
-        if (message.reasoning?.content) {
-            chatMessage.reasoning = message.reasoning.content;
+    /**
+     * OpenRouter marks cache breakpoints Anthropic-style and translates them
+     * for each upstream provider.
+     */
+    augmentChatContent(chatContent) {
+        if (chatContent.prompt_cache_breakpoint) {
+            delete chatContent.prompt_cache_breakpoint;
+            chatContent.cache_control = { type: 'ephemeral' };
         }
-        if (message.reasoning?.details) {
-            chatMessage.reasoning_details = message.reasoning.details;
+    }
+    augmentChatMessage(chatMessage, message) {
+        if (chatMessage.role === 'assistant' && replaysTo(message.reasoning, this.name)) {
+            this.reasoningOf.set(chatMessage, message.reasoning);
         }
     }
+    /**
+     * Assistant messages carry their reasoning back on the same message, which
+     * OpenRouter relays with the turn's text and tool calls, once even when a
+     * message was split into parts.
+     */
     async convertMessages(request, config) {
         const messages = await super.convertMessages(request, config);
-        for (let i = messages.length - 1; i >= 0; i--) {
-            const message = messages[i];
-            // If the message has content & reasoning, move details into a separate field
-            // Annoying OpenRouter doesn't transform it correctly for us
-            if (message.role === 'assistant' &&
-                (message.content?.length) &&
-                (message.reasoning?.length || message.reasoning_details?.length)) {
-                // Remove reasoning details from content
-                const { reasoning, reasoning_details } = message;
-                delete message.reasoning;
-                delete message.reasoning_details;
-                // Insert a new message before this one with the reasoning info
-                messages.splice(i, 0, {
-                    role: 'assistant',
-                    name: message.name,
-                    reasoning,
-                    reasoning_details,
-                });
+        const replayed = new Set();
+        return messages.map((message) => {
+            const reasoning = this.reasoningOf.get(message);
+            if (!reasoning || replayed.has(reasoning)) {
+                return message;
             }
-        }
-        return messages;
+            replayed.add(reasoning);
+            return { ...message, reasoning: reasoning.content ?? undefined, reasoning_details: reasoning.details };
+        });
     }
     /**
-     * OpenRouter does not support image generation
+     * Produce images through chat: image models on OpenRouter answer with
+     * images when asked for the image modality. Runs through the chat hooks.
      */
-    generateImage = undefined;
+    async chatImages(request, images, ctx, defaultModel, config) {
+        const response = await this.createExecutor(config)({
+            model: request.model,
+            messages: [{
+                    role: 'user',
+                    content: [
+                        { type: 'text', content: request.prompt },
+                        ...images.map((image) => ({ type: 'image', content: image })),
+                    ],
+                }],
+            modalities: ['image', 'text'],
+            extra: {
+                image_config: request.size && request.size !== 'auto' ? { aspect_ratio: aspectRatio(request.size) } : undefined,
+                ...request.extra,
+            },
+        }, ctx, { model: config?.defaultModels?.[defaultModel] ?? this.config.defaultModels?.[defaultModel] ?? this.defaults[defaultModel] });
+        return { images: response.images ?? [], model: response.model, usage: response.usage };
+    }
+    generateImage = (request, ctx, config) => this.chatImages(request, [], ctx, 'imageGenerate', config);
+    editImage = (request, ctx, config) => this.chatImages(request, [request.image, ...request.references ?? []], ctx, 'imageEdit', config);
     /**
-     * OpenRouter does not support image generation streaming
+     * Image streaming is not offered; image requests fall back to the
+     * non-streaming methods.
      */
     generateImageStream = undefined;
+    editImageStream = undefined;
     /**
-     * OpenRouter does not support image editing
+     * Transcription streaming is not offered; transcription falls back to
+     * the non-streaming method.
      */
-    editImage = undefined;
+    transcribeStream = undefined;
     /**
-     * OpenRouter does not support image editing
+     * Order documents by relevance to a query.
+     *
+     * @param request Rerank request parameters
+     * @param ctx Context object
+     * @param config Optional configuration override
+     * @returns Documents by relevance, most relevant first
      */
-    editImageStream = undefined;
+    rerank = async (request, ctx, config) => {
+        const run = this.prepare('rerank', request, ctx, undefined, config, undefined, 'rerank');
+        const params = { model: run.model.id, query: request.query, documents: request.documents, top_n: request.topN, ...request.extra };
+        const result = await this.send('rerank', run, request, params, (signal) => run.client.post('/rerank', { body: params, signal }));
+        return this.finish('rerank', run, request, params, {
+            results: result.results.map(({ index, relevance_score }) => ({ index, score: relevance_score })),
+            model: run.model,
+            usage: { cost: result.usage?.cost },
+        });
+    };
     /**
-     * OpenRouter does not support audio transcription
+     * Typed answers about an input, from System One models such as Jev and
+     * Kev or other decision models. A conversation goes in as chat messages.
+     * Decisions are an alpha endpoint, outside the versioned API.
+     *
+     * @param request Decision request parameters
+     * @param ctx Context object
+     * @param config Optional configuration override
+     * @returns Answers by question name
      */
-    transcribe = undefined;
+    decide = async (request, ctx, config) => {
+        const run = this.prepare('decide', request, ctx, undefined, config, undefined, 'decision');
+        const params = {
+            model: run.model.id,
+            state: typeof request.input === 'string' ? request.input : await this.convertMessages({ messages: request.input }, run.config),
+            questions: Object.fromEntries(Object.entries(request.questions).map(([name, question]) => [name, toSystemOneQuestion(question)])),
+            ...request.extra,
+        };
+        const url = new URL('../alpha/decisions', `${run.client.baseURL}/`).href;
+        const result = await this.send('decide', run, request, params, (signal) => run.client.post(url, { body: params, signal }));
+        return this.finish('decide', run, request, params, {
+            answers: Object.fromEntries(Object.entries(result.answers).map(([name, answer]) => [name, toDecisionAnswer(answer)])),
+            model: run.model,
+            usage: { text: { input: result.usage.input_tokens, output: result.usage.output_tokens || undefined }, cost: result.usage.cost },
+        });
+    };
     /**
-     * OpenRouter does not support audio transcription streaming
+     * Start a batch: OpenRouter takes the requests inline.
      */
-    transcribeStream = undefined;
+    async createBatch(batch, run) {
+        const body = { endpoint: batch.endpoint, model: batch.model, requests: batch.lines };
+        const created = await run.retry((signal) => run.client.post('/batches', { body, signal }));
+        return this.toBatchJob(created, run);
+    }
     /**
-     * OpenRouter does not support speech synthesis
+     * Read a batch: OpenRouter returns the results inline once it completes.
      */
-    speech = undefined;
+    async retrieveBatch(job, run) {
+        const batch = await run.retry((signal) => run.client.get(`/batches/${job.id}`, { signal }));
+        const results = batch.results && this.batchResults(batch.results, batch.request_counts.total, run);
+        return { ...this.toBatchJob(batch, run), results: results ?? undefined };
+    }
     /**
-     * OpenRouter does not support embeddings
+     * A batch as @aeye reports it.
      */
-    embed = undefined;
+    toBatchJob(batch, run) {
+        const usage = {};
+        if (batch.usage) {
+            augmentUsage(usage, batch.usage);
+        }
+        return { id: batch.id, provider: this.name, model: run.model.id, status: batch.status, counts: batch.request_counts, error: batch.error?.message, cost: usage.cost };
+    }
     /**
      * Override listModels to use OpenRouter's model API with ZDR support
      */
     async listModels(config) {
+        const { apiKey } = { ...this.config, ...config };
         try {
-            // Fetch both models and ZDR models in parallel
             const [models, zdrModels] = await Promise.all([
-                fetchModels(config.apiKey),
-                fetchZDRModels(config.apiKey),
+                fetchModels(apiKey),
+                fetchZDRModels(apiKey),
             ]);
             return models.map((model) => convertOpenRouterModel(model, zdrModels));
         }