@bolt-foundry/gambit 0.8.0 → 0.8.3

package/esm/src/providers/openrouter.js

@@ -1,80 +1,12 @@
 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;
-function contentToChatCompletionContent(content) {
-    if (typeof content === "string" || content === null)
-        return content;
-    const textParts = [];
-    const out = [];
-    const flushText = () => {
-        if (!textParts.length)
-            return;
-        out.push({ type: "text", text: textParts.join("") });
-        textParts.length = 0;
-    };
-    for (const part of content) {
-        switch (part.type) {
-            case "input_image":
-                if (part.image_url) {
-                    flushText();
-                    out.push({
-                        type: "image_url",
-                        image_url: {
-                            url: part.image_url,
-                            detail: part.detail,
-                        },
-                    });
-                }
-                break;
-            case "input_file": {
-                const label = part.file_url ?? part.filename;
-                if (label)
-                    textParts.push(`[file] ${label}`);
-                break;
-            }
-            case "input_video":
-                textParts.push(`[video] ${part.video_url}`);
-                break;
-            case "refusal":
-                textParts.push(part.refusal);
-                break;
-            case "input_text":
-            case "output_text":
-            case "text":
-            case "summary_text":
-            case "reasoning_text":
-                textParts.push(part.text);
-                break;
-        }
-    }
-    if (!out.length)
-        return textParts.join("");
-    flushText();
-    return out;
-}
-function contentPartsToText(content) {
-    if (typeof content === "string" || content === null)
-        return content;
-    return content.map((part) => {
-        switch (part.type) {
-            case "input_text":
-            case "output_text":
-            case "text":
-            case "summary_text":
-            case "reasoning_text":
-                return part.text;
-            case "refusal":
-                return part.refusal;
-            case "input_file": {
-                const label = part.file_url ?? part.filename;
-                return label ? `[file] ${label}` : "";
-            }
-            case "input_video":
-                return `[video] ${part.video_url}`;
-            default:
-                return "";
-        }
-    }).join("");
+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 ??
@@ -93,273 +25,465 @@ function normalizeMessage(content) {
         tool_calls: toolCalls && toolCalls.length > 0 ? toolCalls : undefined,
     };
 }
-function normalizeInputItems(input, instructions) {
-    const items = typeof input === "string"
-        ? [
-            {
-                type: "message",
-                role: "user",
-                content: input,
-            },
-        ]
-        : input ?? [];
-    if (instructions) {
-        return [
-            {
-                type: "message",
-                role: "system",
-                content: instructions,
+function safeJson(input) {
+    try {
+        const parsed = JSON.parse(input);
+        if (parsed && typeof parsed === "object") {
+            return parsed;
+        }
+    }
+    catch {
+        // fall through
+    }
+    return {};
+}
+function isAsyncIterable(value) {
+    return Boolean(value &&
+        typeof value === "object" &&
+        Symbol.asyncIterator in value);
+}
+function mapUsage(usage) {
+    if (!usage)
+        return undefined;
+    return {
+        promptTokens: usage.input_tokens ?? 0,
+        completionTokens: usage.output_tokens ?? 0,
+        totalTokens: usage.total_tokens ?? 0,
+    };
+}
+function mapStatus(status) {
+    if (!status)
+        return undefined;
+    if (status === "completed")
+        return "completed";
+    if (status === "in_progress" || status === "queued")
+        return "in_progress";
+    return "failed";
+}
+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: [],
             },
-            ...items,
-        ];
+            strict: false,
+        });
     }
-    return items;
 }
-function messagesFromResponseItems(items) {
-    const messages = [];
+function mapToolChoice(toolChoice) {
+    if (!toolChoice)
+        return undefined;
+    if (toolChoice === "auto" || toolChoice === "required")
+        return toolChoice;
+    return { type: "function", name: toolChoice.function.name };
+}
+function mapOpenAIOutputItem(item) {
+    const itemType = item.type;
+    if (itemType === "message") {
+        const message = item;
+        const content = [];
+        for (const part of message.content ?? []) {
+            if (part.type === "output_text") {
+                content.push({ type: "output_text", text: part.text });
+            }
+        }
+        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,
+        };
+    }
+    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: response.created_at,
+        status: mapStatus(response.status ?? undefined),
+        output: outputItems,
+        usage: mapUsage(response.usage),
+        error: mapError(response.error),
+    };
+}
+function toOpenAIInputItems(items) {
+    const mapped = [];
     for (const item of items) {
-        if (item.type !== "message")
-            continue;
-        if (item.role === "tool") {
-            if (!item.tool_call_id)
+        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,
+                    };
+                }
+                return null;
+            })
+                .filter((part) => Boolean(part));
+            if (content.length === 0)
                 continue;
-            const content = contentPartsToText(item.content) ?? "";
-            messages.push({
-                role: "tool",
+            mapped.push({
+                type: "message",
+                role: item.role,
                 content,
-                tool_call_id: item.tool_call_id,
+                id: item.id,
             });
             continue;
         }
-        if (item.role === "assistant") {
-            const content = contentPartsToText(item.content);
-            messages.push({
-                role: "assistant",
-                content,
-                ...(item.name ? { name: item.name } : {}),
-                ...(item.tool_calls ? { tool_calls: item.tool_calls } : {}),
+        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.role === "user") {
-            const content = contentToChatCompletionContent(item.content) ?? "";
-            messages.push({
-                role: "user",
-                content,
-                ...(item.name ? { name: item.name } : {}),
+        if (item.type === "function_call_output") {
+            mapped.push({
+                type: "function_call_output",
+                call_id: item.call_id,
+                output: item.output,
+                id: item.id,
             });
+        }
+    }
+    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;
         }
-        const content = contentPartsToText(item.content) ?? "";
-        messages.push({
-            role: item.role,
-            content,
-            ...(item.name ? { name: item.name } : {}),
-        });
+        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 },
+            });
+        }
     }
-    return messages;
+    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,
+    };
 }
-function applyRequestParams(input, params) {
-    const out = { ...params };
-    const setParam = (key, value) => {
-        if (value === undefined || out[key] !== undefined)
-            return;
-        out[key] = value;
+async function createResponse(client, request, onStreamEvent) {
+    const baseParams = {
+        model: normalizeOpenRouterModel(request.model),
+        input: toOpenAIInputItems(request.input),
+        instructions: request.instructions,
+        tools: undefined,
+        tool_choice: mapToolChoice(request.tool_choice),
+        stream: request.stream,
+        max_output_tokens: request.max_output_tokens,
+        metadata: request.metadata,
     };
-    setParam("temperature", input.temperature);
-    setParam("top_p", input.top_p);
-    setParam("frequency_penalty", input.frequency_penalty);
-    setParam("presence_penalty", input.presence_penalty);
-    setParam("max_tokens", input.max_output_tokens);
-    setParam("top_logprobs", input.top_logprobs);
-    setParam("parallel_tool_calls", input.parallel_tool_calls);
-    if (input.tool_choice !== undefined && out.tool_choice === undefined) {
-        if (typeof input.tool_choice === "string") {
-            out.tool_choice = input.tool_choice === "required"
-                ? "auto"
-                : input.tool_choice;
+    const mappedTools = mapTools(request.tools) ?? [];
+    appendSyntheticTools(mappedTools, request.input);
+    if (mappedTools.length > 0) {
+        baseParams.tools = mappedTools;
+    }
+    const params = { ...(request.params ?? {}), ...baseParams };
+    const debugResponses = dntShim.Deno.env.get("GAMBIT_DEBUG_RESPONSES") === "1";
+    let responseOrStream;
+    try {
+        responseOrStream = await client.responses.create(params);
+    }
+    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);
+            }
         }
-        else if (input.tool_choice.type === "function") {
-            out.tool_choice = input.tool_choice.name
-                ? {
-                    type: "function",
-                    function: { name: input.tool_choice.name },
+        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 });
+                    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,
+                    });
+                    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,
+                    });
+                    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,
+                        });
+                    }
+                    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,
+                        });
+                    }
+                    break;
+                }
+                case "response.completed": {
+                    completed = normalizeOpenAIResponse(event.response);
+                    onStreamEvent?.({ type: "response.completed", response: completed });
+                    break;
+                }
+                case "response.failed": {
+                    const error = mapError(event.response?.error ?? undefined);
+                    onStreamEvent?.({
+                        type: "response.failed",
+                        error: error ?? {},
+                    });
+                    break;
                 }
-                : "auto";
+                default:
+                    break;
+            }
         }
+        if (completed)
+            return completed;
+        throw new Error("OpenRouter responses stream ended without completion.");
     }
-    return out;
+    return normalizeOpenAIResponse(responseOrStream);
 }
 export function createOpenRouterProvider(opts) {
     const debugStream = dntShim.Deno.env.get("GAMBIT_DEBUG_STREAM") === "1";
-    const envFlag = dntShim.Deno.env.get("OPENROUTER_USE_RESPONSES");
-    const useResponses = opts.useResponses !== undefined
-        ? opts.useResponses
-        : envFlag === "0"
-            ? false
-            : envFlag === "1"
-                ? true
-                : true;
-    const 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",
-        },
-    });
-    const openResponseEventTypes = new Set([
-        "response.output_text.delta",
-        "response.output_text.done",
-        "response.output_item.added",
-        "response.output_item.done",
-        "response.content_part.added",
-        "response.content_part.done",
-        "response.function_call_arguments.delta",
-        "response.function_call_arguments.done",
-        "response.refusal.delta",
-        "response.refusal.done",
-        "response.reasoning.delta",
-        "response.reasoning.done",
-        "response.reasoning_summary_text.delta",
-        "response.reasoning_summary_text.done",
-        "response.reasoning_summary_part.added",
-        "response.reasoning_summary_part.done",
-        "response.created",
-        "response.queued",
-        "response.in_progress",
-        "response.failed",
-        "response.incomplete",
-        "response.completed",
-        "error",
-    ]);
-    const buildResponsesRequest = (input) => {
-        const { params: _params, state: _state, onStreamEvent: _onStreamEvent, ...request } = input;
-        return request;
-    };
+    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) {
-            if (useResponses) {
-                const request = buildResponsesRequest(input);
-                if (input.stream) {
-                    let sequence = 0;
-                    let terminalResponse;
-                    const stream = await client.responses.create({
-                        ...request,
-                        stream: true,
-                    });
-                    for await (const event of stream) {
-                        if (!event || !event.type)
-                            continue;
-                        if (openResponseEventTypes.has(event.type)) {
-                            const streamEvent = event;
-                            input.onStreamEvent?.({
-                                ...streamEvent,
-                                sequence_number: streamEvent.sequence_number ?? ++sequence,
-                            });
-                        }
-                        if (event.type === "response.completed" ||
-                            event.type === "response.failed" ||
-                            event.type === "response.incomplete") {
-                            terminalResponse = event.response;
-                        }
-                    }
-                    if (!terminalResponse) {
-                        throw new Error("OpenRouter responses stream ended without terminal response.");
+            return await createResponse(client, input.request, 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,
+                }, (event) => {
+                    if (event.type === "response.output_text.delta") {
+                        input.onStreamText?.(event.delta);
                     }
-                    return terminalResponse;
-                }
-                return await client.responses.create(request);
+                });
+                const mapped = responseItemsToChat(response.output);
+                return {
+                    message: mapped.message,
+                    finishReason: mapped.toolCalls ? "tool_calls" : "stop",
+                    toolCalls: mapped.toolCalls,
+                    usage: response.usage,
+                };
             }
-            const items = normalizeInputItems(input.input, input.instructions ?? null);
-            const messages = messagesFromResponseItems(items);
-            const requestParams = applyRequestParams(input, input.params ?? {});
-            const toolChoice = requestParams.tool_choice ?? "auto";
-            delete requestParams.tool_choice;
             if (input.stream) {
                 if (debugStream) {
-                    logger.log(`[stream-debug] requesting stream model=${input.model} messages=${messages.length} tools=${input.tools?.length ?? 0}`);
+                    logger.log(`[stream-debug] requesting stream model=${input.model} messages=${input.messages.length} tools=${input.tools?.length ?? 0}`);
                 }
-                const responseId = crypto.randomUUID();
-                const createdAt = Math.floor(Date.now() / 1000);
-                const itemId = crypto.randomUUID().replace(/-/g, "").slice(0, 24);
-                let sequence = 0;
-                const emit = (event) => {
-                    input.onStreamEvent?.({
-                        ...event,
-                        sequence_number: event.sequence_number ?? ++sequence,
-                    });
-                };
-                const responseSkeletonBase = {
-                    id: responseId,
-                    object: "response",
-                    created_at: createdAt,
-                    model: input.model,
-                    previous_response_id: input.previous_response_id ?? null,
-                    instructions: input.instructions ?? null,
-                    tool_choice: input.tool_choice,
-                    truncation: input.truncation,
-                    parallel_tool_calls: input.parallel_tool_calls,
-                    text: input.text,
-                    max_output_tokens: input.max_output_tokens,
-                    max_tool_calls: input.max_tool_calls,
-                    store: input.store,
-                    background: input.background,
-                    service_tier: input.service_tier,
-                    metadata: input.metadata,
-                    safety_identifier: input.safety_identifier,
-                    prompt_cache_key: input.prompt_cache_key,
-                    tools: input.tools,
-                    output: [],
-                };
-                emit({
-                    type: "response.queued",
-                    response: { ...responseSkeletonBase, status: "queued" },
-                });
-                const responseSkeleton = {
-                    ...responseSkeletonBase,
-                    status: "in_progress",
-                };
-                emit({ type: "response.created", response: responseSkeleton });
-                emit({ type: "response.in_progress", response: responseSkeleton });
-                emit({
-                    type: "response.output_item.added",
-                    output_index: 0,
-                    item: {
-                        type: "message",
-                        id: itemId,
-                        status: "in_progress",
-                        role: "assistant",
-                        content: [],
-                    },
+                const stream = await client.chat.completions.create({
+                    model: normalizeOpenRouterModel(input.model),
+                    messages: input
+                        .messages,
+                    tools: input
+                        .tools,
+                    tool_choice: "auto",
+                    stream: true,
+                    ...params,
                 });
-                let stream = null;
-                try {
-                    stream = await client.chat.completions.create({
-                        model: input.model,
-                        messages: messages,
-                        tools: input.tools,
-                        tool_choice: toolChoice,
-                        stream: true,
-                        ...requestParams,
-                    });
-                }
-                catch (err) {
-                    const message = err instanceof Error ? err.message : String(err);
-                    emit({ type: "error", error: { code: "openrouter_error", message } });
-                    emit({
-                        type: "response.failed",
-                        response: {
-                            ...responseSkeleton,
-                            status: "failed",
-                            error: { code: "openrouter_error", message },
-                        },
-                    });
-                    throw err;
-                }
                 let finishReason = null;
                 const contentParts = [];
-                let contentPartStarted = false;
                 const toolCallMap = new Map();
                 let chunkCount = 0;
                 let streamedChars = 0;
@@ -373,24 +497,8 @@ export function createOpenRouterProvider(opts) {
                     }
                     const delta = choice.delta;
                     if (typeof delta.content === "string") {
-                        if (!contentPartStarted) {
-                            emit({
-                                type: "response.content_part.added",
-                                item_id: itemId,
-                                output_index: 0,
-                                content_index: 0,
-                                part: { type: "output_text", text: "" },
-                            });
-                            contentPartStarted = true;
-                        }
                         contentParts.push(delta.content);
-                        emit({
-                            type: "response.output_text.delta",
-                            item_id: itemId,
-                            output_index: 0,
-                            content_index: 0,
-                            delta: delta.content,
-                        });
+                        input.onStreamText?.(delta.content);
                         streamedChars += delta.content.length;
                     }
                     else if (Array.isArray(delta.content)) {
@@ -398,24 +506,8 @@ export function createOpenRouterProvider(opts) {
                             .map((c) => (typeof c === "string" ? c : ""))
                             .join("");
                         if (chunkStr) {
-                            if (!contentPartStarted) {
-                                emit({
-                                    type: "response.content_part.added",
-                                    item_id: itemId,
-                                    output_index: 0,
-                                    content_index: 0,
-                                    part: { type: "output_text", text: "" },
-                                });
-                                contentPartStarted = true;
-                            }
                             contentParts.push(chunkStr);
-                            emit({
-                                type: "response.output_text.delta",
-                                item_id: itemId,
-                                output_index: 0,
-                                content_index: 0,
-                                delta: chunkStr,
-                            });
+                            input.onStreamText?.(chunkStr);
                             streamedChars += chunkStr.length;
                         }
                     }
@@ -426,20 +518,12 @@ export function createOpenRouterProvider(opts) {
                                 id: tc.id,
                                 function: { name: tc.function?.name, arguments: "" },
                             };
-                        if (!existing.id) {
-                            existing.id = tc.id ??
-                                crypto.randomUUID().replace(/-/g, "").slice(0, 24);
-                        }
+                        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;
-                            emit({
-                                type: "response.function_call_arguments.delta",
-                                item_id: existing.id,
-                                output_index: 0,
-                                delta: tc.function.arguments,
-                            });
                         }
                         toolCallMap.set(idx, existing);
                     }
@@ -455,135 +539,48 @@ export function createOpenRouterProvider(opts) {
                         arguments: tc.function.arguments,
                     },
                 }));
-                for (const call of tool_calls) {
-                    emit({
-                        type: "response.function_call_arguments.done",
-                        item_id: call.id,
-                        output_index: 0,
-                        arguments: call.function.arguments,
-                    });
-                }
-                const text = contentParts.length ? contentParts.join("") : "";
-                const outputPart = {
-                    type: "output_text",
-                    text,
-                };
                 const message = normalizeMessage({
                     role: "assistant",
-                    content: text.length > 0 ? text : null,
+                    content: contentParts.length ? contentParts.join("") : null,
                     tool_calls,
                 });
-                const outputItem = {
-                    type: "message",
-                    id: itemId,
-                    status: "completed",
-                    role: message.role,
-                    content: text.length > 0 ? [outputPart] : null,
-                    name: message.name,
-                    tool_call_id: message.tool_call_id,
-                    tool_calls: message.tool_calls,
-                };
-                if (contentPartStarted && text.length > 0) {
-                    emit({
-                        type: "response.output_text.done",
-                        item_id: itemId,
-                        output_index: 0,
-                        content_index: 0,
-                        text,
-                    });
-                    emit({
-                        type: "response.content_part.done",
-                        item_id: itemId,
-                        output_index: 0,
-                        content_index: 0,
-                        part: outputPart,
-                    });
-                }
-                emit({
-                    type: "response.output_item.done",
-                    output_index: 0,
-                    item: outputItem,
-                });
-                const completedAt = Math.floor(Date.now() / 1000);
-                const status = finishReason === "length" ? "incomplete" : "completed";
-                const responseResource = {
-                    ...responseSkeleton,
-                    completed_at: completedAt,
-                    status,
-                    output: [outputItem],
-                    finishReason: finishReason ?? "stop",
-                };
-                if (status === "incomplete") {
-                    emit({
-                        type: "response.incomplete",
-                        response: responseResource,
-                    });
-                }
-                else {
-                    emit({
-                        type: "response.completed",
-                        response: responseResource,
-                    });
-                }
+                const toolCalls = tool_calls.length > 0
+                    ? tool_calls.map((tc) => ({
+                        id: tc.id,
+                        name: tc.function.name,
+                        args: safeJson(tc.function.arguments),
+                    }))
+                    : undefined;
                 return {
-                    ...responseResource,
+                    message,
+                    finishReason: finishReason ?? "stop",
+                    toolCalls,
                 };
             }
             const response = await client.chat.completions.create({
-                model: input.model,
-                messages: messages,
-                tools: input.tools,
-                tool_choice: toolChoice,
+                model: normalizeOpenRouterModel(input.model),
+                messages: input
+                    .messages,
+                tools: input
+                    .tools,
+                tool_choice: "auto",
                 stream: false,
-                ...requestParams,
+                ...params,
             });
             const choice = response.choices[0];
             const message = choice.message;
             const normalizedMessage = normalizeMessage(message);
-            const responseId = response.id ?? crypto.randomUUID();
-            const createdAt = Math.floor(Date.now() / 1000);
-            const outputItem = {
-                type: "message",
-                id: crypto.randomUUID().replace(/-/g, "").slice(0, 24),
-                status: "completed",
-                role: normalizedMessage.role,
-                content: normalizedMessage.content,
-                name: normalizedMessage.name,
-                tool_call_id: normalizedMessage.tool_call_id,
-                tool_calls: normalizedMessage.tool_calls,
-            };
-            const finishReason = choice.finish_reason ??
-                "stop";
-            const status = finishReason === "length" ? "incomplete" : "completed";
+            const toolCalls = message.tool_calls?.map((tc) => ({
+                id: tc.id,
+                name: tc.function.name,
+                args: safeJson(tc.function.arguments),
+            }));
             return {
-                id: responseId,
-                object: "response",
-                created_at: createdAt,
-                completed_at: createdAt,
-                status,
-                model: input.model,
-                previous_response_id: input.previous_response_id ?? null,
-                instructions: input.instructions ?? null,
-                tool_choice: input.tool_choice,
-                truncation: input.truncation,
-                parallel_tool_calls: input.parallel_tool_calls,
-                text: input.text,
-                max_output_tokens: input.max_output_tokens,
-                max_tool_calls: input.max_tool_calls,
-                store: input.store,
-                background: input.background,
-                service_tier: input.service_tier,
-                metadata: input.metadata,
-                safety_identifier: input.safety_identifier,
-                prompt_cache_key: input.prompt_cache_key,
-                tools: input.tools,
-                output: [outputItem],
-                finishReason,
+                message: normalizedMessage,
+                finishReason: (choice.finish_reason ?? "stop"),
+                toolCalls,
                 usage: response.usage
                     ? {
-                        input_tokens: response.usage.prompt_tokens ?? 0,
-                        output_tokens: response.usage.completion_tokens ?? 0,
-                        total_tokens: response.usage.total_tokens ?? 0,
                         promptTokens: response.usage.prompt_tokens ?? 0,
                         completionTokens: response.usage.completion_tokens ?? 0,
                         totalTokens: response.usage.total_tokens ?? 0,