theorum 0.1.3 → 0.1.4

package/esm/src/providers/openrouter.js

@@ -1,589 +0,0 @@
-/**
- * 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 { 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';
-function trimApiKey(explicitKey) {
-    if (explicitKey?.trim()) {
-        return explicitKey.trim();
-    }
-    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 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 };
-    }
-}
-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 {
-        role: 'assistant',
-        content: msg.tool_calls.map((call) => ({
-            type: 'tool-call',
-            toolCallId: call.id,
-            toolName: call.function.name,
-            input: parseToolInput(call.function.arguments),
-        })),
-    };
-}
-function historyMessage(msg) {
-    if (msg.role === 'tool') {
-        return toolResultContent(msg);
-    }
-    return assistantToolCallContent(msg) || contentHistoryMessage(msg);
-}
-function contentFromOptionalParts(parts, text) {
-    if (!parts || parts.length === 0) {
-        return stringDefault(text, '');
-    }
-    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;
-    }
-    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 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 schemaForTool(decl) {
-    return decl.parameters ?? { type: 'object', properties: {}, additionalProperties: true };
-}
-function buildTools(dynamicTools) {
-    if (!dynamicTools || dynamicTools.length === 0) {
-        return undefined;
-    }
-    const tools = {};
-    for (const decl of dynamicTools) {
-        tools[decl.name] = tool({
-            description: decl.description ?? '',
-            inputSchema: jsonSchema(schemaForTool(decl)),
-        });
-    }
-    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;
-    }
-    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 {
-        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)) {
-        return undefined;
-    }
-    const out = value.filter((item) => typeof item === 'string');
-    return out.length > 0 ? out : 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 nestedCitations(raw) {
-    for (const candidate of citationCandidates(raw)) {
-        const citations = stringArray(candidate);
-        if (citations) {
-            return citations;
-        }
-    }
-    return 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 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, citations, annotations },
-    };
-}
-function toolArguments(input) {
-    if (input && typeof input === 'object' && !Array.isArray(input)) {
-        return input;
-    }
-    if (input === undefined) {
-        return undefined;
-    }
-    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));
-    }
-    return fromInput;
-}
-function toolResultData(output) {
-    return rawRecord(output);
-}
-function rawThoughtEvent(raw) {
-    const choices = raw.choices;
-    if (!Array.isArray(choices)) {
-        return undefined;
-    }
-    for (const choice of choices) {
-        const delta = rawRecord(rawRecord(choice)?.delta);
-        if (typeof delta?.thinking === 'string') {
-            return { type: 'thought', text: delta.thinking };
-        }
-    }
-    return undefined;
-}
-function rawChoiceMessageEvidence(raw, acc) {
-    const choices = raw.choices;
-    if (!Array.isArray(choices)) {
-        return undefined;
-    }
-    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 rawEvents(raw, acc) {
-    const record = rawRecord(raw);
-    if (!record) {
-        return [];
-    }
-    const events = [];
-    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;
-}
-async function collectRawEvents(res) {
-    if (!res.body) {
-        return [];
-    }
-    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 events;
-}
-function captureFetch(config, setCapture) {
-    const fetchFn = config.fetch ?? fetch;
-    return async (input, init) => {
-        const res = await fetchFn(input, init);
-        setCapture(collectRawEvents(res.clone()).catch(() => []));
-        return res;
-    };
-}
-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;
-    }
-    return evidenceFromMetadata(part.providerMetadata, acc);
-}
-function appendToolInput(part, acc) {
-    if (part.type === 'tool-input-start') {
-        acc.toolInputs.set(part.id, '');
-        return true;
-    }
-    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 eventFromPart(part, acc) {
-    if (appendToolInput(part, acc)) {
-        return [];
-    }
-    const mapped = primaryEventFromPart(part, acc);
-    if (mapped) {
-        return [mapped];
-    }
-    const evidence = providerMetadataEvent(part, acc);
-    return evidence ? [evidence] : [];
-}
-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;
-    }
-}
-function finishEvent(part, acc) {
-    if (acc.emittedTokens) {
-        return undefined;
-    }
-    const event = tokenEvent(part);
-    if (event) {
-        acc.emittedTokens = true;
-    }
-    return event;
-}
-function emitRawEvents(rawCapture, acc) {
-    return (rawCapture ?? Promise.resolve([])).then((events) => events.filter((event) => {
-        if (event.type !== 'evidence') {
-            return true;
-        }
-        if (acc.evidenceSeen) {
-            return false;
-        }
-        acc.evidenceSeen = true;
-        return true;
-    }));
-}
-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;
-        }
-    }
-}
-async function* yieldCapturedRawEvents(context, acc) {
-    for (const event of await emitRawEvents(context.rawCapture(), acc)) {
-        yield event;
-    }
-}
-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 = trimApiKey(config.apiKey);
-    if (!apiKey) {
-        yield missingOpenRouterKey();
-        return;
-    }
-    const acc = createAccumulator();
-    const context = createStreamContext(req, config, apiKey);
-    try {
-        yield* yieldAiSdkStream(req, acc, context);
-        yield* yieldCapturedRawEvents(context, acc);
-        yield* finalEvents(req, acc);
-    }
-    catch (err) {
-        yield* yieldCapturedRawEventsUnchecked(context);
-        yield { type: 'error', error: publicError(err) };
-    }
-}
-function* finalEvents(req, acc) {
-    if (acc.errored) {
-        return;
-    }
-    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 through AI SDK Core. */
-function createOpenRouterProvider(config = {}) {
-    return {
-        complete: (req) => streamOpenRouter(req, config),
-    };
-}
-export { createOpenRouterProvider, resolveOpenRouterModel, toOpenRouterPayload };

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

@@ -1,7 +0,0 @@
-/**
- * PCM → WAV helpers shared by speech transports.
- *
- * @module
- */
-/** Wrap raw PCM bytes in a RIFF/WAVE container. */
-export declare function wrapPcmAsWav(pcm: Uint8Array, sampleRate?: number): Uint8Array;

package/esm/src/providers/pcm.js

@@ -1,35 +0,0 @@
-/**
- * PCM → WAV helpers shared by speech transports.
- *
- * @module
- */
-const SAMPLE_RATE = 24000;
-function writeAscii(view, offset, str) {
-    for (let i = 0; i < str.length; i++)
-        view.setUint8(offset + i, str.charCodeAt(i));
-}
-/** Wrap raw PCM bytes in a RIFF/WAVE container. */
-export function wrapPcmAsWav(pcm, sampleRate = SAMPLE_RATE) {
-    const numChannels = 1;
-    const bitsPerSample = 16;
-    const byteRate = (sampleRate * numChannels * bitsPerSample) / 8;
-    const blockAlign = (numChannels * bitsPerSample) / 8;
-    const dataSize = pcm.length;
-    const buf = new ArrayBuffer(44 + dataSize);
-    const view = new DataView(buf);
-    writeAscii(view, 0, 'RIFF');
-    view.setUint32(4, 36 + dataSize, true);
-    writeAscii(view, 8, 'WAVE');
-    writeAscii(view, 12, 'fmt ');
-    view.setUint32(16, 16, true);
-    view.setUint16(20, 1, true); // PCM
-    view.setUint16(22, numChannels, true);
-    view.setUint32(24, sampleRate, true);
-    view.setUint32(28, byteRate, true);
-    view.setUint16(32, blockAlign, true);
-    view.setUint16(34, bitsPerSample, true);
-    writeAscii(view, 36, 'data');
-    view.setUint32(40, dataSize, true);
-    new Uint8Array(buf, 44).set(pcm);
-    return new Uint8Array(buf);
-}

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

@@ -1,15 +0,0 @@
-/**
- * Google Interactions provider adapter.
- *
- * This adapter converts THEORUM's provider-neutral request into the Google
- * Interactions wire format and streams normalized `TurnEvent` objects.
- * Speech-role turns use `response_format: audio` + `speech_config` (same
- * transport as chat/image).
- *
- * @module
- */
-import type { ModelProvider } from '../kernel/types.js';
-import { type GeminiTransport } from './keys.js';
-/** Create a `ModelProvider` backed by Google Interactions streaming. */
-declare function createInteractionsProvider(transport: GeminiTransport): ModelProvider;
-export { createInteractionsProvider };