@bolt-foundry/gambit 0.8.1 → 0.8.5-rc.10

package/esm/src/providers/openrouter.js

@@ -0,0 +1,886 @@
+import * as dntShim from "../../_dnt.shims.js";
+import OpenAI from "openai";
+import { GAMBIT_TOOL_CONTEXT, GAMBIT_TOOL_INIT, } from "@bolt-foundry/gambit-core";
+const logger = console;
+export const OPENROUTER_PREFIX = "openrouter/";
+function normalizeOpenRouterModel(model) {
+    return model.startsWith(OPENROUTER_PREFIX)
+        ? model.slice(OPENROUTER_PREFIX.length)
+        : model;
+}
+function normalizeMessage(content) {
+    const toolCalls = content.tool_calls ??
+        undefined;
+    return {
+        role: content.role,
+        content: typeof content.content === "string"
+            ? content.content
+            : Array.isArray(content.content)
+                ? content.content
+                    .map((c) => (typeof c === "string" ? c : ""))
+                    .join("")
+                : "",
+        name: content.name,
+        tool_call_id: content.tool_call_id,
+        tool_calls: toolCalls && toolCalls.length > 0 ? toolCalls : undefined,
+    };
+}
+function safeJson(input) {
+    try {
+        const parsed = JSON.parse(input);
+        if (parsed && typeof parsed === "object") {
+            return parsed;
+        }
+    }
+    catch {
+        // fall through
+    }
+    return {};
+}
+function toJsonValue(value) {
+    if (value === null || typeof value === "string" || typeof value === "boolean") {
+        return value;
+    }
+    if (typeof value === "number") {
+        return Number.isFinite(value) ? value : String(value);
+    }
+    if (Array.isArray(value)) {
+        return value.map((entry) => toJsonValue(entry));
+    }
+    if (value && typeof value === "object") {
+        const out = {};
+        for (const [key, entry] of Object.entries(value)) {
+            if (entry === undefined)
+                continue;
+            out[key] = toJsonValue(entry);
+        }
+        return out;
+    }
+    return String(value);
+}
+function isExtensionResponseItem(item) {
+    return item.type.includes(":");
+}
+function isAsyncIterable(value) {
+    return Boolean(value &&
+        typeof value === "object" &&
+        Symbol.asyncIterator in value);
+}
+function mapUsage(usage) {
+    if (!usage)
+        return undefined;
+    const reasoningTokens = usage.output_tokens_details?.reasoning_tokens ?? undefined;
+    const out = {
+        promptTokens: usage.input_tokens ?? 0,
+        completionTokens: usage.output_tokens ?? 0,
+        totalTokens: usage.total_tokens ?? 0,
+    };
+    if (typeof reasoningTokens === "number") {
+        out.reasoningTokens = reasoningTokens;
+    }
+    return out;
+}
+function mapStatus(status) {
+    if (!status)
+        return undefined;
+    if (status === "completed")
+        return "completed";
+    if (status === "in_progress" || status === "queued")
+        return "in_progress";
+    return "failed";
+}
+function mapReasoning(reasoning) {
+    if (!reasoning)
+        return undefined;
+    const out = {};
+    if (reasoning.effort !== undefined)
+        out.effort = reasoning.effort;
+    if (reasoning.summary !== undefined)
+        out.summary = reasoning.summary;
+    return Object.keys(out).length > 0 ? out : undefined;
+}
+function stripUndefined(input) {
+    const out = { ...input };
+    for (const [key, value] of Object.entries(out)) {
+        if (value === undefined) {
+            delete out[key];
+        }
+    }
+    return out;
+}
+function mapError(error) {
+    if (!error)
+        return undefined;
+    return { code: error.code, message: error.message };
+}
+function mapTools(tools) {
+    if (!tools || tools.length === 0)
+        return undefined;
+    return tools.map((tool) => ({
+        type: "function",
+        name: tool.function.name,
+        description: tool.function.description ?? null,
+        parameters: normalizeToolParameters(tool.function.parameters),
+        strict: false,
+    }));
+}
+function normalizeToolParameters(parameters) {
+    const normalized = structuredClone(parameters ?? {});
+    if (normalized.type !== "object") {
+        return normalized;
+    }
+    if (normalized.properties === undefined) {
+        normalized.properties = {};
+    }
+    const props = normalized.properties;
+    if (props && typeof props === "object" && !Array.isArray(props)) {
+        const requiredKeys = Array.isArray(normalized.required)
+            ? normalized.required.filter((key) => typeof key === "string" && key in props)
+            : [];
+        for (const [key, value] of Object.entries(props)) {
+            if (!value || typeof value !== "object" || Array.isArray(value))
+                continue;
+            if (!("type" in value))
+                continue;
+            if (value.type === "object" && value.additionalProperties !== false) {
+                props[key] = {
+                    ...value,
+                    additionalProperties: false,
+                };
+            }
+        }
+        if (requiredKeys.length > 0) {
+            normalized.required = requiredKeys;
+        }
+    }
+    const additional = normalized.additionalProperties;
+    if (additional !== false) {
+        normalized.additionalProperties = false;
+    }
+    return normalized;
+}
+function appendSyntheticTools(tools, input) {
+    const needed = new Set();
+    for (const item of input) {
+        if (item.type !== "function_call")
+            continue;
+        if (item.name === GAMBIT_TOOL_CONTEXT || item.name === GAMBIT_TOOL_INIT) {
+            needed.add(item.name);
+        }
+    }
+    for (const name of needed) {
+        if (tools.some((tool) => tool.name === name))
+            continue;
+        tools.push({
+            type: "function",
+            name,
+            description: "Synthetic Gambit context payload.",
+            parameters: {
+                type: "object",
+                properties: {},
+                additionalProperties: false,
+                required: [],
+            },
+            strict: false,
+        });
+    }
+}
+function mapToolChoice(toolChoice) {
+    if (!toolChoice)
+        return undefined;
+    if (toolChoice === "none" || toolChoice === "auto" ||
+        toolChoice === "required") {
+        return toolChoice;
+    }
+    if (toolChoice.type === "allowed_tools") {
+        return {
+            type: "allowed_tools",
+            tools: toolChoice.tools,
+            mode: toolChoice.mode ?? "auto",
+        };
+    }
+    return { type: "function", name: toolChoice.function.name };
+}
+function mapResponseContentPart(part) {
+    if (!part || typeof part !== "object")
+        return null;
+    if (typeof part.text !== "string")
+        return null;
+    if (part.type === "output_text") {
+        return { type: "output_text", text: part.text };
+    }
+    if (part.type === "summary_text") {
+        return { type: "summary_text", text: part.text };
+    }
+    if (part.type === "reasoning_text") {
+        return { type: "reasoning_text", text: part.text };
+    }
+    if (part.type === "input_text") {
+        return { type: "input_text", text: part.text };
+    }
+    return null;
+}
+function mapOpenAIOutputItem(item) {
+    const itemType = item.type;
+    if (itemType === "message") {
+        const message = item;
+        const content = (message.content ?? [])
+            .map((part) => mapResponseContentPart(part))
+            .filter((part) => Boolean(part));
+        if (content.length === 0)
+            return null;
+        return {
+            type: "message",
+            role: "assistant",
+            content,
+            id: message.id,
+        };
+    }
+    if (itemType === "function_call") {
+        const call = item;
+        return {
+            type: "function_call",
+            call_id: call.call_id,
+            name: call.name,
+            arguments: call.arguments,
+            id: call.id,
+        };
+    }
+    if (itemType === "reasoning") {
+        const reasoning = item;
+        const content = (reasoning.content ?? [])
+            .map((part) => mapResponseContentPart(part))
+            .filter((part) => Boolean(part));
+        const summary = (reasoning.summary ?? [])
+            .map((part) => mapResponseContentPart(part))
+            .filter((part) => Boolean(part));
+        return {
+            type: "reasoning",
+            id: reasoning.id,
+            content: content.length > 0 ? content : undefined,
+            summary,
+            encrypted_content: reasoning.encrypted_content,
+        };
+    }
+    if (typeof itemType === "string" && itemType.includes(":")) {
+        const raw = item;
+        const payloadEntries = Object.entries(raw).filter(([key, value]) => {
+            if (key === "type" || key === "id")
+                return false;
+            if (value === undefined)
+                return false;
+            return true;
+        });
+        let data;
+        if (payloadEntries.length === 1 && payloadEntries[0][0] === "data") {
+            data = toJsonValue(payloadEntries[0][1]);
+        }
+        else {
+            const payloadObject = {};
+            for (const [key, value] of payloadEntries) {
+                payloadObject[key] = toJsonValue(value);
+            }
+            data = payloadObject;
+        }
+        return {
+            type: itemType,
+            id: typeof raw.id === "string" ? raw.id : undefined,
+            data,
+        };
+    }
+    return null;
+}
+function normalizeOpenAIResponse(response) {
+    const outputItems = (response.output ?? [])
+        .map(mapOpenAIOutputItem)
+        .filter((item) => Boolean(item));
+    return {
+        id: response.id,
+        object: "response",
+        model: response.model,
+        created_at: response.created_at,
+        created: response.created_at,
+        completed_at: response.completed_at ??
+            null,
+        previous_response_id: response.previous_response_id ?? null,
+        instructions: response.instructions ?? null,
+        reasoning: response
+            .reasoning ?? null,
+        status: mapStatus(response.status ?? undefined),
+        output: outputItems,
+        usage: mapUsage(response.usage),
+        error: mapError(response.error) ?? null,
+        metadata: response.metadata,
+        max_output_tokens: response.max_output_tokens ?? null,
+        max_tool_calls: response.max_tool_calls ?? null,
+        parallel_tool_calls: response.parallel_tool_calls,
+        store: response.store,
+    };
+}
+function toOpenAIInputItems(items) {
+    const mapped = [];
+    for (const item of items) {
+        if (item.type === "message") {
+            const isAssistant = item.role === "assistant";
+            const content = item.content
+                .map((part) => {
+                if (part.type === "output_text") {
+                    return {
+                        type: "output_text",
+                        text: part.text,
+                    };
+                }
+                if (part.type === "input_text") {
+                    return {
+                        type: isAssistant ? "output_text" : "input_text",
+                        text: part.text,
+                    };
+                }
+                if (part.type === "summary_text") {
+                    return {
+                        type: "summary_text",
+                        text: part.text,
+                    };
+                }
+                if (part.type === "reasoning_text") {
+                    return {
+                        type: "reasoning_text",
+                        text: part.text,
+                    };
+                }
+                return null;
+            })
+                .filter((part) => Boolean(part));
+            if (content.length === 0)
+                continue;
+            mapped.push({
+                type: "message",
+                role: item.role,
+                content,
+                id: item.id,
+            });
+            continue;
+        }
+        if (item.type === "function_call") {
+            mapped.push({
+                type: "function_call",
+                call_id: item.call_id,
+                name: item.name,
+                arguments: item.arguments,
+                id: item.id,
+            });
+            continue;
+        }
+        if (item.type === "function_call_output") {
+            mapped.push({
+                type: "function_call_output",
+                call_id: item.call_id,
+                output: item.output,
+                id: item.id,
+            });
+            continue;
+        }
+        if (item.type === "reasoning") {
+            mapped.push({
+                type: "reasoning",
+                id: item.id,
+                content: (item.content ?? []).map((part) => ({
+                    type: part.type,
+                    text: part.text,
+                })),
+                summary: item.summary.map((part) => ({
+                    type: part.type,
+                    text: part.text,
+                })),
+                encrypted_content: item.encrypted_content ?? null,
+            });
+        }
+        if (isExtensionResponseItem(item)) {
+            mapped.push({
+                type: item.type,
+                id: item.id,
+                data: item.data,
+            });
+        }
+    }
+    return mapped;
+}
+function chatMessagesToResponseItems(messages) {
+    const items = [];
+    for (const message of messages) {
+        if (message.role === "tool") {
+            if (message.tool_call_id &&
+                typeof message.content === "string") {
+                items.push({
+                    type: "function_call_output",
+                    call_id: message.tool_call_id,
+                    output: message.content,
+                });
+            }
+            continue;
+        }
+        if (message.role === "system" || message.role === "user" ||
+            message.role === "assistant") {
+            const content = [];
+            if (typeof message.content === "string" && message.content.length > 0) {
+                content.push({
+                    type: message.role === "assistant" ? "output_text" : "input_text",
+                    text: message.content,
+                });
+            }
+            if (content.length > 0) {
+                items.push({
+                    type: "message",
+                    role: message.role,
+                    content,
+                });
+            }
+        }
+        if (message.role === "assistant" && message.tool_calls) {
+            for (const call of message.tool_calls) {
+                items.push({
+                    type: "function_call",
+                    call_id: call.id,
+                    name: call.function.name,
+                    arguments: call.function.arguments,
+                });
+            }
+        }
+    }
+    return items;
+}
+function responseItemsToChat(items) {
+    const textParts = [];
+    const toolCalls = [];
+    const messageToolCalls = [];
+    for (const item of items) {
+        if (item.type === "message" && item.role === "assistant") {
+            for (const part of item.content) {
+                if (part.type === "output_text") {
+                    textParts.push(part.text);
+                }
+            }
+        }
+        if (item.type === "function_call") {
+            toolCalls.push({
+                id: item.call_id,
+                name: item.name,
+                args: safeJson(item.arguments),
+            });
+            messageToolCalls.push({
+                id: item.call_id,
+                type: "function",
+                function: { name: item.name, arguments: item.arguments },
+            });
+        }
+    }
+    const content = textParts.length > 0 ? textParts.join("") : null;
+    const message = {
+        role: "assistant",
+        content,
+        tool_calls: messageToolCalls.length > 0 ? messageToolCalls : undefined,
+    };
+    return {
+        message,
+        toolCalls: toolCalls.length > 0 ? toolCalls : undefined,
+    };
+}
+async function createResponse(client, request, signal, onStreamEvent) {
+    const baseParams = {
+        model: normalizeOpenRouterModel(request.model),
+        input: toOpenAIInputItems(request.input),
+        instructions: request.instructions,
+        tools: undefined,
+        tool_choice: mapToolChoice(request.tool_choice),
+        previous_response_id: request.previous_response_id,
+        reasoning: mapReasoning(request.reasoning),
+        parallel_tool_calls: request.parallel_tool_calls,
+        max_tool_calls: request.max_tool_calls,
+        store: request.store,
+        include: request.include,
+        text: request.text,
+        stream_options: request.stream_options,
+        background: request.background,
+        truncation: request.truncation,
+        service_tier: request.service_tier,
+        top_logprobs: request.top_logprobs,
+        safety_identifier: request.safety_identifier,
+        prompt_cache_key: request.prompt_cache_key,
+        temperature: request.temperature,
+        top_p: request.top_p,
+        frequency_penalty: request.frequency_penalty,
+        presence_penalty: request.presence_penalty,
+        stream: request.stream,
+        max_output_tokens: request.max_output_tokens,
+        metadata: request.metadata,
+    };
+    const mappedTools = mapTools(request.tools) ?? [];
+    appendSyntheticTools(mappedTools, request.input);
+    if (mappedTools.length > 0) {
+        baseParams.tools = mappedTools;
+    }
+    const params = { ...(request.params ?? {}), ...stripUndefined(baseParams) };
+    const debugResponses = dntShim.Deno.env.get("GAMBIT_DEBUG_RESPONSES") === "1";
+    let responseOrStream;
+    try {
+        responseOrStream = await client.responses.create(params, signal ? { signal } : undefined);
+    }
+    catch (err) {
+        if (debugResponses) {
+            logger.error("[responses-debug] request", params);
+            if (err instanceof OpenAI.APIError) {
+                logger.error("[responses-debug] error", err.error);
+            }
+            else {
+                logger.error("[responses-debug] error", err);
+            }
+        }
+        throw err;
+    }
+    if (request.stream &&
+        isAsyncIterable(responseOrStream)) {
+        let completed = null;
+        for await (const event of responseOrStream) {
+            if (!event || typeof event !== "object" || !("type" in event)) {
+                continue;
+            }
+            switch (event.type) {
+                case "response.created": {
+                    const mapped = normalizeOpenAIResponse(event.response);
+                    onStreamEvent?.({
+                        type: "response.created",
+                        response: mapped,
+                        sequence_number: event
+                            .sequence_number,
+                    });
+                    break;
+                }
+                case "response.output_text.delta":
+                    onStreamEvent?.({
+                        type: "response.output_text.delta",
+                        output_index: event.output_index,
+                        delta: event.delta,
+                        item_id: event.item_id,
+                        content_index: event.content_index,
+                        sequence_number: event
+                            .sequence_number,
+                        logprobs: event.logprobs,
+                    });
+                    break;
+                case "response.output_text.done":
+                    onStreamEvent?.({
+                        type: "response.output_text.done",
+                        output_index: event.output_index,
+                        text: event.text,
+                        item_id: event.item_id,
+                        content_index: event.content_index,
+                        sequence_number: event
+                            .sequence_number,
+                    });
+                    break;
+                case "response.output_item.added": {
+                    const item = mapOpenAIOutputItem(event.item);
+                    if (item) {
+                        onStreamEvent?.({
+                            type: "response.output_item.added",
+                            output_index: event.output_index,
+                            item,
+                            sequence_number: event
+                                .sequence_number,
+                        });
+                    }
+                    break;
+                }
+                case "response.output_item.done": {
+                    const item = mapOpenAIOutputItem(event.item);
+                    if (item) {
+                        onStreamEvent?.({
+                            type: "response.output_item.done",
+                            output_index: event.output_index,
+                            item,
+                            sequence_number: event
+                                .sequence_number,
+                        });
+                    }
+                    break;
+                }
+                case "response.reasoning.delta":
+                    if (typeof event.delta === "string") {
+                        onStreamEvent?.({
+                            type: "response.reasoning.delta",
+                            output_index: event.output_index,
+                            item_id: event.item_id,
+                            content_index: event.content_index,
+                            delta: event.delta,
+                            sequence_number: event
+                                .sequence_number,
+                            obfuscation: event.obfuscation,
+                        });
+                    }
+                    break;
+                case "response.reasoning.done":
+                    onStreamEvent?.({
+                        type: "response.reasoning.done",
+                        output_index: event.output_index,
+                        item_id: event.item_id,
+                        content_index: event.content_index,
+                        text: event.text,
+                        sequence_number: event
+                            .sequence_number,
+                    });
+                    break;
+                case "response.reasoning_summary_text.delta":
+                    if (typeof event.delta === "string") {
+                        onStreamEvent?.({
+                            type: "response.reasoning_summary_text.delta",
+                            output_index: event.output_index,
+                            item_id: event.item_id,
+                            summary_index: event.summary_index,
+                            delta: event.delta,
+                            sequence_number: event
+                                .sequence_number,
+                            obfuscation: event.obfuscation,
+                        });
+                    }
+                    break;
+                case "response.reasoning_summary_text.done":
+                    onStreamEvent?.({
+                        type: "response.reasoning_summary_text.done",
+                        output_index: event.output_index,
+                        item_id: event.item_id,
+                        summary_index: event.summary_index,
+                        text: event.text,
+                        sequence_number: event
+                            .sequence_number,
+                    });
+                    break;
+                case "response.reasoning_summary_part.added":
+                    if (event.part && typeof event.part === "object" &&
+                        "type" in event.part &&
+                        "text" in event.part &&
+                        typeof event.part.text === "string") {
+                        onStreamEvent?.({
+                            type: "response.reasoning_summary_part.added",
+                            output_index: event.output_index,
+                            item_id: event.item_id,
+                            summary_index: event.summary_index,
+                            part: event.part,
+                            sequence_number: event
+                                .sequence_number,
+                        });
+                    }
+                    break;
+                case "response.reasoning_summary_part.done":
+                    if (event.part && typeof event.part === "object" &&
+                        "type" in event.part &&
+                        "text" in event.part &&
+                        typeof event.part.text === "string") {
+                        onStreamEvent?.({
+                            type: "response.reasoning_summary_part.done",
+                            output_index: event.output_index,
+                            item_id: event.item_id,
+                            summary_index: event.summary_index,
+                            part: event.part,
+                            sequence_number: event
+                                .sequence_number,
+                        });
+                    }
+                    break;
+                case "response.completed": {
+                    completed = normalizeOpenAIResponse(event.response);
+                    onStreamEvent?.({
+                        type: "response.completed",
+                        response: completed,
+                        sequence_number: event
+                            .sequence_number,
+                    });
+                    break;
+                }
+                case "response.failed": {
+                    const error = mapError(event.response?.error ?? undefined);
+                    onStreamEvent?.({
+                        type: "response.failed",
+                        error: error ?? {},
+                        sequence_number: event
+                            .sequence_number,
+                    });
+                    break;
+                }
+                default:
+                    break;
+            }
+        }
+        if (completed)
+            return completed;
+        throw new Error("OpenRouter responses stream ended without completion.");
+    }
+    return normalizeOpenAIResponse(responseOrStream);
+}
+export function createOpenRouterProvider(opts) {
+    const debugStream = dntShim.Deno.env.get("GAMBIT_DEBUG_STREAM") === "1";
+    const client = (opts.client ??
+        new OpenAI({
+            apiKey: opts.apiKey,
+            baseURL: opts.baseURL ?? "https://openrouter.ai/api/v1",
+            defaultHeaders: {
+                "HTTP-Referer": opts.referer ?? "https://gambit.local",
+                "X-Title": opts.title ?? "Gambit CLI",
+            },
+        }));
+    return {
+        async responses(input) {
+            return await createResponse(client, input.request, input.signal, input.onStreamEvent);
+        },
+        async chat(input) {
+            const params = input.params ?? {};
+            if (opts.enableResponses) {
+                const response = await createResponse(client, {
+                    model: normalizeOpenRouterModel(input.model),
+                    input: chatMessagesToResponseItems(input.messages),
+                    tools: input.tools,
+                    stream: input.stream,
+                    params,
+                }, input.signal, (event) => {
+                    if (event.type === "response.output_text.delta") {
+                        input.onStreamText?.(event.delta);
+                    }
+                });
+                const mapped = responseItemsToChat(response.output);
+                return {
+                    message: mapped.message,
+                    finishReason: mapped.toolCalls ? "tool_calls" : "stop",
+                    toolCalls: mapped.toolCalls,
+                    usage: response.usage,
+                };
+            }
+            if (input.stream) {
+                if (debugStream) {
+                    logger.log(`[stream-debug] requesting stream model=${input.model} messages=${input.messages.length} tools=${input.tools?.length ?? 0}`);
+                }
+                const stream = await client.chat.completions.create({
+                    model: normalizeOpenRouterModel(input.model),
+                    messages: input
+                        .messages,
+                    tools: input
+                        .tools,
+                    tool_choice: "auto",
+                    stream: true,
+                    ...params,
+                }, input.signal ? { signal: input.signal } : undefined);
+                let finishReason = null;
+                const contentParts = [];
+                const toolCallMap = new Map();
+                let chunkCount = 0;
+                let streamedChars = 0;
+                for await (const chunk of stream) {
+                    chunkCount++;
+                    const choice = chunk.choices[0];
+                    const fr = choice.finish_reason;
+                    if (fr === "stop" || fr === "tool_calls" || fr === "length" ||
+                        fr === null) {
+                        finishReason = fr ?? finishReason;
+                    }
+                    const delta = choice.delta;
+                    if (typeof delta.content === "string") {
+                        contentParts.push(delta.content);
+                        input.onStreamText?.(delta.content);
+                        streamedChars += delta.content.length;
+                    }
+                    else if (Array.isArray(delta.content)) {
+                        const chunkStr = delta.content
+                            .map((c) => (typeof c === "string" ? c : ""))
+                            .join("");
+                        if (chunkStr) {
+                            contentParts.push(chunkStr);
+                            input.onStreamText?.(chunkStr);
+                            streamedChars += chunkStr.length;
+                        }
+                    }
+                    for (const tc of delta.tool_calls ?? []) {
+                        const idx = tc.index ?? 0;
+                        const existing = toolCallMap.get(idx) ??
+                            {
+                                id: tc.id,
+                                function: { name: tc.function?.name, arguments: "" },
+                            };
+                        if (tc.id)
+                            existing.id = tc.id;
+                        if (tc.function?.name)
+                            existing.function.name = tc.function.name;
+                        if (tc.function?.arguments) {
+                            existing.function.arguments += tc.function.arguments;
+                        }
+                        toolCallMap.set(idx, existing);
+                    }
+                }
+                if (debugStream) {
+                    logger.log(`[stream-debug] completed stream chunks=${chunkCount} streamedChars=${streamedChars} finishReason=${finishReason}`);
+                }
+                const tool_calls = Array.from(toolCallMap.values()).map((tc) => ({
+                    id: tc.id ?? crypto.randomUUID().replace(/-/g, "").slice(0, 24),
+                    type: "function",
+                    function: {
+                        name: tc.function.name ?? "",
+                        arguments: tc.function.arguments,
+                    },
+                }));
+                const message = normalizeMessage({
+                    role: "assistant",
+                    content: contentParts.length ? contentParts.join("") : null,
+                    tool_calls,
+                });
+                const toolCalls = tool_calls.length > 0
+                    ? tool_calls.map((tc) => ({
+                        id: tc.id,
+                        name: tc.function.name,
+                        args: safeJson(tc.function.arguments),
+                    }))
+                    : undefined;
+                return {
+                    message,
+                    finishReason: finishReason ?? "stop",
+                    toolCalls,
+                };
+            }
+            const response = await client.chat.completions.create({
+                model: normalizeOpenRouterModel(input.model),
+                messages: input
+                    .messages,
+                tools: input
+                    .tools,
+                tool_choice: "auto",
+                stream: false,
+                ...params,
+            }, input.signal ? { signal: input.signal } : undefined);
+            const choice = response.choices[0];
+            const message = choice.message;
+            const normalizedMessage = normalizeMessage(message);
+            const toolCalls = message.tool_calls?.map((tc) => ({
+                id: tc.id,
+                name: tc.function.name,
+                args: safeJson(tc.function.arguments),
+            }));
+            return {
+                message: normalizedMessage,
+                finishReason: (choice.finish_reason ?? "stop"),
+                toolCalls,
+                usage: response.usage
+                    ? (() => {
+                        const usage = {
+                            promptTokens: response.usage.prompt_tokens ?? 0,
+                            completionTokens: response.usage.completion_tokens ?? 0,
+                            totalTokens: response.usage.total_tokens ?? 0,
+                        };
+                        const details = response.usage;
+                        const value = details.completion_tokens_details
+                            ?.reasoning_tokens ??
+                            details.output_tokens_details?.reasoning_tokens;
+                        return typeof value === "number"
+                            ? { ...usage, reasoningTokens: value }
+                            : usage;
+                    })()
+                    : undefined,
+            };
+        },
+    };
+}