theorum 0.1.2 → 0.1.3

package/esm/src/providers/openrouter.js

@@ -1,95 +1,208 @@
 /**
- * OpenRouter-compatible streaming provider adapter.
+ * OpenRouter provider adapter powered by Vercel AI SDK Core.
  *
- * This module maps THEORUM requests to OpenAI-style chat completions, including
- * reasoning deltas, tool calls, citations, structured output, and token usage.
+ * THEORUM keeps the public `ModelProvider` and `TurnEvent` contract; AI SDK
+ * owns the OpenRouter call, stream parsing, provider compatibility, and tool
+ * call normalization.
  *
  * @module
  */
-import "../../_dnt.polyfills.js";
-import { publicError, TheorumError } from '../guardrails/error.js';
+import { createOpenRouter } from '@openrouter/ai-sdk-provider';
+import { jsonSchema, streamText, tool, } from 'ai';
+import { publicError } from '../guardrails/error.js';
 import { tryStructured } from '../kernel/engine/delta.js';
+import { getTool } from '../kernel/registry/catalog.js';
 import { resolveOpenRouterModel, toOpenRouterPayload, } from './openrouter-payload.js';
 import { takeSsePayloads } from './sse.js';
-const HTTP_OK = 200;
-const DEFAULT_OPENROUTER_BASE_URL = 'https://openrouter.ai/api/v1';
-async function* readSseLines(res) {
-    if (!res.body) {
-        throw new TheorumError('empty OpenRouter stream');
+function trimApiKey(explicitKey) {
+    if (explicitKey?.trim()) {
+        return explicitKey.trim();
     }
-    const reader = res.body.getReader();
-    const decoder = new TextDecoder();
-    let buffer = '';
-    let pendingEvent = '';
-    while (true) {
-        const { done, value } = await reader.read();
-        if (done) {
-            break;
-        }
-        buffer += decoder.decode(value, { stream: true });
-        const taken = takeSsePayloads(buffer, pendingEvent);
-        buffer = taken.rest;
-        pendingEvent = taken.pendingEvent;
-        for (const payload of taken.payloads) {
-            yield payload;
-        }
+    return undefined;
+}
+function createAccumulator() {
+    return {
+        text: '',
+        evidenceSeen: false,
+        emittedTokens: false,
+        errored: false,
+        toolInputs: new Map(),
+    };
+}
+function mediaPart(part) {
+    if (part.type === 'text') {
+        return { type: 'text', text: part.text };
+    }
+    if (part.type === 'image') {
+        return {
+            type: 'image',
+            image: `data:${part.mimeType};base64,${part.data}`,
+        };
     }
+    return { type: 'file', mediaType: part.mimeType, data: part.data };
 }
-function extractReasoning(delta) {
-    if (typeof delta.reasoning === 'string') {
-        return delta.reasoning;
+function contentFromParts(parts) {
+    if (parts.every((part) => part.type === 'text')) {
+        return parts
+            .map((part) => (part.type === 'text' ? part.text : ''))
+            .filter(Boolean)
+            .join('\n');
+    }
+    return parts.map(mediaPart);
+}
+function parseToolInput(raw) {
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        return { _raw: raw };
     }
-    if (typeof delta.thinking === 'string') {
-        return delta.thinking;
+}
+function stringDefault(value, fallback) {
+    return value === undefined ? fallback : value;
+}
+function optionalSingle(value) {
+    return value === undefined ? undefined : [value];
+}
+function fallbackToolCallId(name) {
+    return `call_${stringDefault(name, 'tool')}`;
+}
+function toolResultContent(msg) {
+    const toolName = stringDefault(msg.name, 'tool');
+    return {
+        role: 'tool',
+        content: [
+            {
+                type: 'tool-result',
+                toolCallId: stringDefault(msg.tool_call_id, fallbackToolCallId(msg.name)),
+                toolName,
+                output: { type: 'text', value: stringDefault(msg.content, '') },
+            },
+        ],
+    };
+}
+function assistantToolCallContent(msg) {
+    if (!msg.tool_calls || msg.tool_calls.length === 0) {
+        return null;
     }
-    return undefined;
+    return {
+        role: 'assistant',
+        content: msg.tool_calls.map((call) => ({
+            type: 'tool-call',
+            toolCallId: call.id,
+            toolName: call.function.name,
+            input: parseToolInput(call.function.arguments),
+        })),
+    };
 }
-function applyToolCallObject(callObj, toolMap) {
-    let index = 0;
-    if (typeof callObj.index === 'number') {
-        index = callObj.index;
+function historyMessage(msg) {
+    if (msg.role === 'tool') {
+        return toolResultContent(msg);
     }
-    const current = toolMap.get(index) ?? { index, arguments: '' };
-    if (typeof callObj.id === 'string') {
-        current.id = callObj.id;
+    return assistantToolCallContent(msg) || contentHistoryMessage(msg);
+}
+function contentFromOptionalParts(parts, text) {
+    if (!parts || parts.length === 0) {
+        return stringDefault(text, '');
     }
-    const fn = callObj.function;
-    if (fn) {
-        if (typeof fn.name === 'string') {
-            current.name = (current.name ?? '') + fn.name;
-        }
-        if (typeof fn.arguments === 'string') {
-            current.arguments += fn.arguments;
-        }
+    return contentFromParts(parts);
+}
+function contentHistoryMessage(msg) {
+    const content = contentFromOptionalParts(msg.parts, msg.content);
+    return { role: msg.role, content };
+}
+function sourceValue(part, key) {
+    const source = part;
+    const value = source[key];
+    return typeof value === 'string' ? value : undefined;
+}
+function sourceUrl(part) {
+    return sourceValue(part, 'url');
+}
+function sourceTitle(part) {
+    return sourceValue(part, 'title') ?? sourceUrl(part);
+}
+function sourceList(title, url) {
+    if (title === undefined || url === undefined) {
+        return undefined;
     }
-    toolMap.set(index, current);
+    return [{ title, uri: url, type: 'web' }];
+}
+function sourceEvent(part) {
+    const raw = part;
+    const url = sourceUrl(part);
+    const title = sourceTitle(part);
+    return {
+        type: 'evidence',
+        evidence: {
+            provider: 'openrouter',
+            raw,
+            citations: optionalSingle(url),
+            sources: sourceList(title, url),
+        },
+    };
 }
-function processToolCalls(rawCalls, toolMap) {
-    for (const rawCall of rawCalls) {
-        if (rawCall && typeof rawCall === 'object') {
-            applyToolCallObject(rawCall, toolMap);
+function buildMessages(req) {
+    const messages = [];
+    for (const msg of req.history ?? []) {
+        const wired = historyMessage(msg);
+        if (wired) {
+            messages.push(wired);
         }
     }
+    if (req.input.length > 0) {
+        messages.push({ role: 'user', content: contentFromParts(req.input) });
+    }
+    return messages;
 }
-function processDelta(delta, acc) {
-    const events = [];
-    const reasoning = extractReasoning(delta);
-    if (reasoning) {
-        events.push({ type: 'thought', text: reasoning });
+function schemaForTool(decl) {
+    return decl.parameters ?? { type: 'object', properties: {}, additionalProperties: true };
+}
+function buildTools(dynamicTools) {
+    if (!dynamicTools || dynamicTools.length === 0) {
+        return undefined;
     }
-    if (typeof delta.content === 'string') {
-        acc.text += delta.content;
-        events.push({ type: 'text', text: delta.content });
+    const tools = {};
+    for (const decl of dynamicTools) {
+        tools[decl.name] = tool({
+            description: decl.description ?? '',
+            inputSchema: jsonSchema(schemaForTool(decl)),
+        });
     }
-    if (Array.isArray(delta.tool_calls)) {
-        processToolCalls(delta.tool_calls, acc.toolCalls);
+    return tools;
+}
+function openRouterPlugins(req) {
+    const plugins = req.builtins
+        .map((id) => getTool(id)?.openRouterPlugin)
+        .filter((id) => Boolean(id))
+        .map((id) => ({ id }));
+    return plugins.length > 0 ? plugins : undefined;
+}
+function openRouterSettings(req) {
+    const plugins = openRouterPlugins(req);
+    if (!plugins) {
+        return undefined;
     }
-    const evidence = evidenceFromRecord(delta);
-    if (evidence && !acc.evidenceSeen) {
-        acc.evidenceSeen = true;
-        events.push(evidence);
+    return { plugins };
+}
+function tokensFromUsage(usage) {
+    const input = usage.inputTokens ?? 0;
+    const output = usage.outputTokens ?? 0;
+    const total = usage.totalTokens ?? input + output;
+    if (input === 0 && output === 0 && total === 0) {
+        return undefined;
     }
-    return events;
+    return {
+        input,
+        output,
+        total,
+    };
+}
+function rawRecord(value) {
+    if (value && typeof value === 'object' && !Array.isArray(value)) {
+        return value;
+    }
+    return undefined;
 }
 function stringArray(value) {
     if (!Array.isArray(value)) {
@@ -98,232 +211,376 @@ function stringArray(value) {
     const out = value.filter((item) => typeof item === 'string');
     return out.length > 0 ? out : undefined;
 }
-function recordField(record, key) {
-    const value = record[key];
-    if (value && typeof value === 'object' && !Array.isArray(value)) {
-        return value;
-    }
-    return undefined;
+function metadataRecord(raw, key) {
+    return rawRecord(raw[key]);
+}
+function citationCandidates(raw) {
+    const openrouter = metadataRecord(raw, 'openrouter') ?? {};
+    return [
+        raw.citations,
+        metadataRecord(raw, 'providerMetadata')?.citations,
+        metadataRecord(raw, 'provider_metadata')?.citations,
+        openrouter.citations,
+        metadataRecord(openrouter, 'providerMetadata')?.citations,
+        metadataRecord(openrouter, 'provider_metadata')?.citations,
+    ];
 }
-function firstEvidenceRaw(record) {
-    for (const key of [
-        'annotations',
-        'citations',
-        'search_results',
-        'searchResults',
-        'provider_metadata',
-        'providerMetadata',
-    ]) {
-        const value = record[key];
-        if (value !== undefined) {
-            return value;
+function nestedCitations(raw) {
+    for (const candidate of citationCandidates(raw)) {
+        const citations = stringArray(candidate);
+        if (citations) {
+            return citations;
         }
     }
     return undefined;
 }
-function evidenceCitations(record) {
-    return (stringArray(record.citations) ??
-        stringArray(recordField(record, 'provider_metadata')?.citations) ??
-        stringArray(recordField(record, 'providerMetadata')?.citations));
-}
-function evidenceAnnotations(record) {
-    return Array.isArray(record.annotations) ? record.annotations : undefined;
+function metadataAnnotations(raw) {
+    const openrouter = metadataRecord(raw, 'openrouter');
+    if (Array.isArray(raw.annotations)) {
+        return raw.annotations;
+    }
+    if (Array.isArray(openrouter?.annotations)) {
+        return openrouter.annotations;
+    }
+    return undefined;
 }
-function evidenceFromRecord(record) {
-    if (firstEvidenceRaw(record) === undefined) {
+function evidenceFromMetadata(metadata, acc) {
+    const raw = rawRecord(metadata);
+    if (!raw || acc.evidenceSeen) {
+        return undefined;
+    }
+    const citations = nestedCitations(raw);
+    const annotations = metadataAnnotations(raw);
+    if (!citations && !annotations) {
         return undefined;
     }
+    acc.evidenceSeen = true;
     return {
         type: 'evidence',
-        evidence: {
-            provider: 'openrouter',
-            raw: record,
-            citations: evidenceCitations(record),
-            annotations: evidenceAnnotations(record),
-        },
+        evidence: { provider: 'openrouter', raw, citations, annotations },
     };
 }
-function parseUsage(usageRaw) {
-    if (!usageRaw || typeof usageRaw !== 'object') {
+function toolArguments(input) {
+    if (input && typeof input === 'object' && !Array.isArray(input)) {
+        return input;
+    }
+    if (input === undefined) {
         return undefined;
     }
-    const u = usageRaw;
-    let input = 0;
-    if (typeof u.prompt_tokens === 'number') {
-        input = u.prompt_tokens;
+    return { value: input };
+}
+function isEmptyRecord(input) {
+    return Boolean(input) && Object.keys(input ?? {}).length === 0;
+}
+function toolCallArguments(part, acc) {
+    const fromInput = toolArguments(part.input);
+    const rawInput = acc.toolInputs.get(part.toolCallId);
+    if ((!fromInput || isEmptyRecord(fromInput)) && rawInput) {
+        return toolArguments(parseToolInput(rawInput));
     }
-    let output = 0;
-    if (typeof u.completion_tokens === 'number') {
-        output = u.completion_tokens;
+    return fromInput;
+}
+function toolResultData(output) {
+    return rawRecord(output);
+}
+function rawThoughtEvent(raw) {
+    const choices = raw.choices;
+    if (!Array.isArray(choices)) {
+        return undefined;
     }
-    let total = input + output;
-    if (typeof u.total_tokens === 'number') {
-        total = u.total_tokens;
+    for (const choice of choices) {
+        const delta = rawRecord(rawRecord(choice)?.delta);
+        if (typeof delta?.thinking === 'string') {
+            return { type: 'thought', text: delta.thinking };
+        }
     }
-    return { input, output, total };
+    return undefined;
 }
-function parseToolArgs(rawArgs) {
-    try {
-        return JSON.parse(rawArgs);
+function rawChoiceMessageEvidence(raw, acc) {
+    const choices = raw.choices;
+    if (!Array.isArray(choices)) {
+        return undefined;
     }
-    catch {
-        return { _raw: rawArgs };
+    for (const choice of choices) {
+        const message = rawRecord(rawRecord(choice)?.message);
+        if (!message) {
+            continue;
+        }
+        const evidence = evidenceFromMetadata(message, acc);
+        if (evidence) {
+            return evidence;
+        }
     }
+    return undefined;
 }
-function emitRemainingTools(acc) {
+function rawEvents(raw, acc) {
+    const record = rawRecord(raw);
+    if (!record) {
+        return [];
+    }
     const events = [];
-    for (const tool of acc.toolCalls.values()) {
-        if (tool.name) {
-            let args;
-            if (tool.arguments) {
-                args = parseToolArgs(tool.arguments);
-            }
-            events.push({
-                type: 'tool',
-                tool: {
-                    name: tool.name,
-                    arguments: args,
-                    ...(tool.id ? { id: tool.id } : {}),
-                },
-            });
-        }
+    const thought = rawThoughtEvent(record);
+    if (thought) {
+        events.push(thought);
+    }
+    const evidence = evidenceFromMetadata(record, acc);
+    if (evidence) {
+        events.push(evidence);
+    }
+    const messageEvidence = rawChoiceMessageEvidence(record, acc);
+    if (messageEvidence) {
+        events.push(messageEvidence);
     }
     return events;
 }
-function buildHeaders(apiKey, config) {
-    const headers = {
-        'Content-Type': 'application/json',
-        Authorization: `Bearer ${apiKey}`,
-    };
-    if (config.siteUrl) {
-        headers['HTTP-Referer'] = config.siteUrl;
+async function collectRawEvents(res) {
+    if (!res.body) {
+        return [];
     }
-    if (config.siteName) {
-        headers['X-Title'] = config.siteName;
+    const reader = res.body.getReader();
+    const decoder = new TextDecoder();
+    const events = [];
+    const acc = createAccumulator();
+    let buffer = '';
+    let pendingEvent = '';
+    while (true) {
+        const { done, value } = await reader.read();
+        if (done) {
+            break;
+        }
+        buffer += decoder.decode(value, { stream: true });
+        const taken = takeSsePayloads(buffer, pendingEvent);
+        buffer = taken.rest;
+        pendingEvent = taken.pendingEvent;
+        for (const payload of taken.payloads) {
+            events.push(...rawEvents(payload, acc));
+        }
     }
-    return headers;
+    return events;
 }
-async function postOpenRouter(req, config, apiKey) {
-    const baseUrl = config.baseUrl ?? DEFAULT_OPENROUTER_BASE_URL;
-    const url = `${baseUrl.replace(/\/+$/, '')}/chat/completions`;
+function captureFetch(config, setCapture) {
     const fetchFn = config.fetch ?? fetch;
-    const headers = buildHeaders(apiKey, config);
-    const body = JSON.stringify(toOpenRouterPayload(req, config));
-    return await fetchFn(url, { method: 'POST', headers, body });
+    return async (input, init) => {
+        const res = await fetchFn(input, init);
+        setCapture(collectRawEvents(res.clone()).catch(() => []));
+        return res;
+    };
 }
-function processChoiceDeltas(choices, acc) {
-    if (!Array.isArray(choices)) {
-        return [];
+function toolCallEvent(part, acc) {
+    return {
+        type: 'tool',
+        tool: {
+            name: part.toolName,
+            arguments: toolCallArguments(part, acc),
+            id: part.toolCallId,
+        },
+    };
+}
+function toolResultEvent(part) {
+    return {
+        type: 'tool',
+        tool: {
+            name: part.toolName,
+            arguments: toolArguments(part.input),
+            result: {
+                status: 'ok',
+                data: toolResultData(part.output),
+                finding: typeof part.output === 'string' ? part.output : undefined,
+            },
+            id: part.toolCallId,
+        },
+    };
+}
+function tokenEvent(part) {
+    const tokens = tokensFromUsage(part.totalUsage);
+    return tokens ? { type: 'tokens', tokens } : undefined;
+}
+function providerMetadataEvent(part, acc) {
+    if (!('providerMetadata' in part)) {
+        return undefined;
     }
-    const events = [];
-    for (const choice of choices) {
-        events.push(...processChoiceDelta(choice, acc));
+    return evidenceFromMetadata(part.providerMetadata, acc);
+}
+function appendToolInput(part, acc) {
+    if (part.type === 'tool-input-start') {
+        acc.toolInputs.set(part.id, '');
+        return true;
     }
-    return events;
+    if (part.type === 'tool-input-delta') {
+        const current = acc.toolInputs.get(part.id) ?? '';
+        acc.toolInputs.set(part.id, current + part.delta);
+        return true;
+    }
+    return false;
 }
-function processChoiceDelta(choice, acc) {
-    if (!choice || typeof choice !== 'object') {
+function eventFromPart(part, acc) {
+    if (appendToolInput(part, acc)) {
         return [];
     }
-    const c = choice;
-    const events = processChoiceDeltaPayload(c.delta, acc);
-    const evidence = evidenceFromChoiceMessage(c.message, acc);
-    if (evidence) {
-        events.push(evidence);
+    const mapped = primaryEventFromPart(part, acc);
+    if (mapped) {
+        return [mapped];
     }
-    return events;
+    const evidence = providerMetadataEvent(part, acc);
+    return evidence ? [evidence] : [];
 }
-function processChoiceDeltaPayload(delta, acc) {
-    if (!delta || typeof delta !== 'object') {
-        return [];
+function primaryEventFromPart(part, acc) {
+    switch (part.type) {
+        case 'text-delta':
+            acc.text += part.text;
+            return { type: 'text', text: part.text };
+        case 'reasoning-delta':
+            return { type: 'thought', text: part.text };
+        case 'tool-call':
+            return toolCallEvent(part, acc);
+        case 'tool-result':
+            return toolResultEvent(part);
+        case 'source':
+            return sourceEvent(part);
+        case 'finish':
+            return finishEvent(part, acc);
+        case 'error':
+            acc.errored = true;
+            return { type: 'error', error: publicError(part.error) };
+        default:
+            return undefined;
     }
-    return processDelta(delta, acc);
 }
-function evidenceFromChoiceMessage(message, acc) {
-    if (!message || typeof message !== 'object') {
+function finishEvent(part, acc) {
+    if (acc.emittedTokens) {
         return undefined;
     }
-    const evidence = evidenceFromRecord(message);
-    if (!evidence || acc.evidenceSeen) {
-        return undefined;
+    const event = tokenEvent(part);
+    if (event) {
+        acc.emittedTokens = true;
     }
-    acc.evidenceSeen = true;
-    return evidence;
+    return event;
 }
-function* yieldRemainingStreamEvents(req, acc) {
-    for (const ev of emitRemainingTools(acc)) {
-        yield ev;
-    }
-    if (req.structured && acc.text) {
-        const structured = tryStructured(acc.text);
-        if (structured) {
-            yield structured;
+function emitRawEvents(rawCapture, acc) {
+    return (rawCapture ?? Promise.resolve([])).then((events) => events.filter((event) => {
+        if (event.type !== 'evidence') {
+            return true;
         }
-    }
-    yield { type: 'done' };
+        if (acc.evidenceSeen) {
+            return false;
+        }
+        acc.evidenceSeen = true;
+        return true;
+    }));
 }
-function evidenceFromPayload(payload, acc) {
-    const evidence = evidenceFromRecord(payload);
-    if (!evidence || acc.evidenceSeen) {
-        return undefined;
+function createStreamContext(req, config, apiKey) {
+    let rawCapture;
+    const openrouter = createOpenRouter({
+        apiKey,
+        baseURL: config.baseUrl,
+        headers: openRouterHeaders(config),
+        fetch: captureFetch(config, (capture) => {
+            rawCapture = capture;
+        }),
+        compatibility: 'strict',
+    });
+    return {
+        openrouter,
+        modelName: resolveOpenRouterModel(req.model, config.modelMap, {
+            apiId: req.apiId,
+            openRouterId: req.openRouterId,
+        }),
+        rawCapture: () => rawCapture,
+    };
+}
+function streamTextOptions(req, context) {
+    return {
+        model: context.openrouter.chat(context.modelName, openRouterSettings(req)),
+        system: req.system,
+        messages: buildMessages(req),
+        allowSystemInMessages: true,
+        temperature: req.temperature,
+        maxOutputTokens: req.maxOutputTokens,
+        tools: buildTools(req.dynamicTools),
+        providerOptions: providerOptionsFor(req),
+        includeRawChunks: true,
+        onError: () => undefined,
+    };
+}
+async function* yieldAiSdkStream(req, acc, context) {
+    const result = streamText(streamTextOptions(req, context));
+    for await (const part of result.fullStream) {
+        if (part.type === 'raw') {
+            req.tapGemini?.(rawRecord(part.rawValue) ?? { rawValue: part.rawValue });
+            for (const event of rawEvents(part.rawValue, acc)) {
+                yield event;
+            }
+            continue;
+        }
+        for (const event of eventFromPart(part, acc)) {
+            yield event;
+        }
     }
-    acc.evidenceSeen = true;
-    return evidence;
 }
-function* eventsFromPayload(payload, acc) {
-    const evidence = evidenceFromPayload(payload, acc);
-    if (evidence) {
-        yield evidence;
+async function* yieldCapturedRawEvents(context, acc) {
+    for (const event of await emitRawEvents(context.rawCapture(), acc)) {
+        yield event;
     }
-    for (const ev of processChoiceDeltas(payload.choices, acc)) {
-        yield ev;
+}
+async function* yieldCapturedRawEventsUnchecked(context) {
+    for (const event of await (context.rawCapture() ?? Promise.resolve([]))) {
+        yield event;
     }
 }
+function missingOpenRouterKey() {
+    return { type: 'error', error: publicError('missing OpenRouter API key') };
+}
 async function* streamOpenRouter(req, config) {
-    const apiKey = resolveOpenRouterApiKey(config.apiKey);
+    const apiKey = trimApiKey(config.apiKey);
     if (!apiKey) {
-        yield { type: 'error', error: publicError('missing OpenRouter API key') };
+        yield missingOpenRouterKey();
         return;
     }
+    const acc = createAccumulator();
+    const context = createStreamContext(req, config, apiKey);
     try {
-        const res = await postOpenRouter(req, config, apiKey);
-        if (res.status !== HTTP_OK) {
-            yield { type: 'error', error: publicError(`OpenRouter HTTP ${String(res.status)}`) };
-            return;
-        }
-        const acc = { text: '', toolCalls: new Map(), evidenceSeen: false };
-        let emittedTokens = false;
-        let sawPayload = false;
-        for await (const payload of readSseLines(res)) {
-            sawPayload = true;
-            req.tapGemini?.(payload);
-            for (const ev of eventsFromPayload(payload, acc)) {
-                yield ev;
-            }
-            const usage = parseUsage(payload.usage);
-            if (usage && !emittedTokens) {
-                emittedTokens = true;
-                yield { type: 'tokens', tokens: usage };
-            }
-        }
-        if (!sawPayload) {
-            yield { type: 'error', error: publicError('empty OpenRouter stream') };
-            return;
-        }
-        yield* yieldRemainingStreamEvents(req, acc);
+        yield* yieldAiSdkStream(req, acc, context);
+        yield* yieldCapturedRawEvents(context, acc);
+        yield* finalEvents(req, acc);
     }
     catch (err) {
+        yield* yieldCapturedRawEventsUnchecked(context);
         yield { type: 'error', error: publicError(err) };
     }
 }
-/** Resolve an OpenRouter API key supplied explicitly by the host application. */
-export function resolveOpenRouterApiKey(explicitKey) {
-    if (explicitKey?.trim()) {
-        return explicitKey.trim();
+function* finalEvents(req, acc) {
+    if (acc.errored) {
+        return;
     }
-    return undefined;
+    if (req.structured && acc.text) {
+        const structured = tryStructured(acc.text);
+        if (structured) {
+            yield structured;
+        }
+    }
+    yield { type: 'done' };
+}
+function providerOptionsFor(req) {
+    if (req.thinking === 'none') {
+        return undefined;
+    }
+    return {
+        openrouter: {
+            reasoning: { effort: req.thinking },
+        },
+    };
+}
+function openRouterHeaders(config) {
+    const headers = {};
+    if (config.siteUrl) {
+        headers['HTTP-Referer'] = config.siteUrl;
+    }
+    if (config.siteName) {
+        headers['X-Title'] = config.siteName;
+    }
+    return Object.keys(headers).length > 0 ? headers : undefined;
 }
-/** Create a `ModelProvider` backed by OpenRouter-compatible chat completions. */
+/** Create a `ModelProvider` backed by OpenRouter through AI SDK Core. */
 function createOpenRouterProvider(config = {}) {
     return {
         complete: (req) => streamOpenRouter(req, config),