theorum 0.1.4 → 0.1.5

package/esm/src/providers/openrouter-payload.js

@@ -0,0 +1,179 @@
+/**
+ * OpenRouter payload builder.
+ *
+ * Converts THEORUM provider requests into OpenAI-compatible chat completion
+ * payloads for OpenRouter and compatible gateways.
+ *
+ * @module
+ */
+import { getTool } from '../kernel/registry/catalog.js';
+import { getStructured } from '../kernel/registry/schemas.js';
+/**
+ * Resolve a THEORUM model id to an OpenRouter model string.
+ * Prefer `openRouterId` / `apiId` from the profile model spec on the request.
+ */
+function resolveOpenRouterModel(modelId, customMap, wire) {
+    if (customMap?.[modelId]) {
+        return customMap[modelId];
+    }
+    if (wire?.openRouterId) {
+        return wire.openRouterId;
+    }
+    if (wire?.apiId?.includes('/')) {
+        return wire.apiId;
+    }
+    if (wire?.apiId) {
+        return `google/${wire.apiId}`;
+    }
+    if (String(modelId).includes('/')) {
+        return String(modelId);
+    }
+    return String(modelId);
+}
+/** Map THEORUM thinking level to OpenRouter/OpenAI `reasoning.effort`. */
+function mapThinkingEffort(thinking) {
+    return thinking;
+}
+function wireAudioPart(part) {
+    let format = 'mp3';
+    if (part.mimeType.includes('wav')) {
+        format = 'wav';
+    }
+    return {
+        type: 'input_audio',
+        input_audio: {
+            data: part.data,
+            format,
+        },
+    };
+}
+function wireMessageContent(parts) {
+    const isAllText = parts.every((p) => p.type === 'text');
+    if (isAllText) {
+        return parts
+            .map((p) => {
+            if (p.type === 'text') {
+                return p.text;
+            }
+            return '';
+        })
+            .join('\n');
+    }
+    return parts.map((part) => {
+        if (part.type === 'text') {
+            return { type: 'text', text: part.text };
+        }
+        if (part.type === 'image') {
+            return {
+                type: 'image_url',
+                image_url: { url: `data:${part.mimeType};base64,${part.data}` },
+            };
+        }
+        if (part.type === 'audio') {
+            return wireAudioPart(part);
+        }
+        return { type: 'text', text: '' };
+    });
+}
+function wireHistoryMessage(msg) {
+    let content = msg.content ?? '';
+    if (msg.parts && msg.parts.length > 0) {
+        content = wireMessageContent(msg.parts);
+    }
+    const wired = {
+        role: msg.role,
+        content,
+    };
+    if (msg.tool_calls && msg.tool_calls.length > 0) {
+        wired.tool_calls = msg.tool_calls;
+    }
+    if (msg.tool_call_id) {
+        wired.tool_call_id = msg.tool_call_id;
+    }
+    if (msg.name) {
+        wired.name = msg.name;
+    }
+    return wired;
+}
+function wireTools(dynamicTools) {
+    if (!dynamicTools || dynamicTools.length === 0) {
+        return [];
+    }
+    return dynamicTools.map((t) => ({
+        type: 'function',
+        function: {
+            name: t.name,
+            description: t.description ?? '',
+            parameters: t.parameters ?? { type: 'object', properties: {} },
+        },
+    }));
+}
+function buildMessages(req) {
+    const messages = [];
+    if (req.system) {
+        messages.push({ role: 'system', content: req.system });
+    }
+    if (req.history && req.history.length > 0) {
+        for (const h of req.history) {
+            messages.push(wireHistoryMessage(h));
+        }
+    }
+    if (req.input.length > 0) {
+        messages.push({
+            role: 'user',
+            content: wireMessageContent(req.input),
+        });
+    }
+    return messages;
+}
+function resolveResponseFormat(structured) {
+    if (!structured) {
+        return undefined;
+    }
+    const spec = getStructured(structured);
+    if (!spec.jsonSchema) {
+        return undefined;
+    }
+    return {
+        type: 'json_schema',
+        json_schema: {
+            name: String(structured),
+            strict: true,
+            schema: spec.jsonSchema,
+        },
+    };
+}
+/** Convert a provider-neutral request into an OpenRouter chat completion payload. */
+function toOpenRouterPayload(req, config) {
+    const model = resolveOpenRouterModel(req.model, config.modelMap, {
+        apiId: req.apiId,
+        openRouterId: req.openRouterId,
+    });
+    const messages = buildMessages(req);
+    const payload = {
+        model,
+        stream: true,
+        messages,
+        temperature: req.temperature,
+        max_tokens: req.maxOutputTokens,
+    };
+    const effort = mapThinkingEffort(req.thinking);
+    payload.reasoning = { effort };
+    const responseFormat = resolveResponseFormat(req.structured);
+    if (responseFormat) {
+        payload.response_format = responseFormat;
+    }
+    const tools = wireTools(req.dynamicTools);
+    if (tools.length > 0) {
+        payload.tools = tools;
+    }
+    const plugins = req.builtins
+        .map((id) => getTool(id)?.openRouterPlugin)
+        .filter((id) => Boolean(id))
+        .map((id) => ({ id }));
+    if (plugins.length > 0) {
+        payload.plugins = plugins;
+    }
+    return payload;
+}
+export { resolveOpenRouterModel, toOpenRouterPayload };

package/esm/src/providers/openrouter.d.ts

@@ -0,0 +1,15 @@
+/**
+ * OpenRouter provider adapter powered by Vercel AI SDK Core.
+ *
+ * THEORUM keeps the public `ModelProvider` and `TurnEvent` contract; AI SDK
+ * owns the OpenRouter call, stream parsing, provider compatibility, and tool
+ * call normalization.
+ *
+ * @module
+ */
+import type { ModelProvider } from '../kernel/types.js';
+import { type OpenRouterConfig, resolveOpenRouterModel, toOpenRouterPayload } from './openrouter-payload.js';
+/** Create a `ModelProvider` backed by OpenRouter through AI SDK Core. */
+declare function createOpenRouterProvider(config?: OpenRouterConfig): ModelProvider;
+export type { OpenRouterConfig };
+export { createOpenRouterProvider, resolveOpenRouterModel, toOpenRouterPayload };