theorum 0.1.2 → 0.1.3

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

@@ -0,0 +1,7 @@
+/**
+ * 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

@@ -0,0 +1,35 @@
+/**
+ * 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

@@ -3,11 +3,13 @@
  *
  * 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 GeminiTransport } from '../guardrails/keys.js';
 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 };

package/esm/src/providers/provider.js

@@ -3,16 +3,51 @@
  *
  * 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 { publicError, TheorumError } from '../guardrails/error.js';
-import { fetchGemini } from '../guardrails/keys.js';
 import { eventsFromComplete, eventsFromDelta, extractTokenEvent, groundingFromEvent, tryStructured, } from '../kernel/engine/delta.js';
 import { tapFetch } from './google-tap.js';
 import { toInteractionsBody } from './interactions.js';
+import { fetchGemini } from './keys.js';
+import { wrapPcmAsWav } from './pcm.js';
 import { INTERACTIONS_URL, takeSsePayloads } from './sse.js';
 const HTTP_OK = 200;
+function base64ToBytes(data) {
+    const bin = atob(data);
+    const out = new Uint8Array(bin.length);
+    for (let i = 0; i < bin.length; i++)
+        out[i] = bin.charCodeAt(i);
+    return out;
+}
+function bytesToBase64(bytes) {
+    let bin = '';
+    for (let i = 0; i < bytes.length; i++)
+        bin += String.fromCharCode(bytes[i]);
+    return btoa(bin);
+}
+function isRawPcmMime(mime) {
+    const lower = mime.toLowerCase();
+    return lower === 'audio/pcm' || lower === 'audio/l16' || lower === 'audio/raw';
+}
+/** Google TTS returns raw PCM; wrap as WAV for hosts (matches OpenRouter pcm path). */
+function normalizeSpeechMedia(event, speech) {
+    if (!(speech && event.type === 'media' && event.media)) {
+        return event;
+    }
+    const { mimeType, data } = event.media;
+    if (!isRawPcmMime(mimeType)) {
+        return event;
+    }
+    const wav = wrapPcmAsWav(base64ToBytes(data));
+    return {
+        type: 'media',
+        media: { mimeType: 'audio/wav', data: bytesToBase64(wav) },
+    };
+}
 async function* readSseRecords(res) {
     if (!res.body) {
         throw new TheorumError('empty Gemini stream');
@@ -82,6 +117,13 @@ function withTap(req, transport) {
     };
 }
 async function* streamComplete(req, transport) {
+    if (!req.geminiBucket) {
+        yield {
+            type: 'error',
+            error: publicError('missing Gemini vault bucket for Interactions'),
+        };
+        return;
+    }
     const res = await fetchGemini(INTERACTIONS_URL, { method: 'POST', body: JSON.stringify(toInteractionsBody(req)) }, req.geminiBucket, withTap(req, transport));
     if (res.status !== HTTP_OK) {
         const errorBody = await res.text().catch(() => '');
@@ -92,11 +134,12 @@ async function* streamComplete(req, transport) {
         return;
     }
     const acc = { text: '' };
+    const speech = Boolean(req.speech);
     for await (const payload of readSseRecords(res)) {
         req.tapGemini?.(payload);
         const events = foldPayload(payload, acc);
         for (const event of events) {
-            yield event;
+            yield normalizeSpeechMedia(event, speech);
         }
     }
     if (req.structured && acc.text) {

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

@@ -0,0 +1,23 @@
+/**
+ * OpenAI-compatible `/audio/speech` transport (internal).
+ *
+ * Hosts use `createProvider(profile, { openRouter })` — this module is selected
+ * when the profile is an openAi speech role. Not a separate public door.
+ *
+ * @module
+ */
+import type { ModelProvider, ProviderCompleteRequest, TurnEvent } from '../kernel/types.js';
+/** Credentials for the openAi speech path (same shape as OpenRouter chat config + voice). */
+export interface SpeechProviderConfig {
+    apiKey?: string;
+    /** Fallback TTS voice when the profile does not pin `outputs.speech.voice`. */
+    voice?: string;
+    baseUrl?: string;
+    siteUrl?: string;
+    siteName?: string;
+    fetch?: typeof fetch;
+}
+declare function streamSpeech(req: ProviderCompleteRequest, config?: SpeechProviderConfig): AsyncGenerator<TurnEvent>;
+/** Internal ModelProvider for openAi speech roles. */
+declare function createSpeechProvider(config?: SpeechProviderConfig): ModelProvider;
+export { createSpeechProvider, streamSpeech };

package/esm/src/providers/speech.js

@@ -0,0 +1,125 @@
+/**
+ * OpenAI-compatible `/audio/speech` transport (internal).
+ *
+ * Hosts use `createProvider(profile, { openRouter })` — this module is selected
+ * when the profile is an openAi speech role. Not a separate public door.
+ *
+ * @module
+ */
+import { publicError } from '../guardrails/error.js';
+import { wrapPcmAsWav } from './pcm.js';
+const HTTP_OK = 200;
+function bytesToBase64(bytes) {
+    let bin = '';
+    for (let i = 0; i < bytes.length; i++)
+        bin += String.fromCharCode(bytes[i]);
+    return btoa(bin);
+}
+function extractInputText(input) {
+    return input
+        .filter((p) => p.type === 'text')
+        .map((p) => (p.type === 'text' ? p.text : ''))
+        .join(' ')
+        .trim();
+}
+function resolveSpeechWireModel(req) {
+    if (req.openRouterId) {
+        return req.openRouterId;
+    }
+    if (req.apiId.includes('/')) {
+        return req.apiId;
+    }
+    if (req.apiId) {
+        return `google/${req.apiId}`;
+    }
+    return String(req.model);
+}
+function buildHeaders(apiKey, config) {
+    const headers = {
+        Authorization: `Bearer ${apiKey}`,
+        'Content-Type': 'application/json',
+    };
+    if (config.siteUrl) {
+        headers['HTTP-Referer'] = config.siteUrl;
+    }
+    if (config.siteName) {
+        headers['X-Title'] = config.siteName;
+    }
+    return headers;
+}
+function buildPayload(req, text, speech, configVoice) {
+    const voice = speech?.voice ?? configVoice;
+    const format = speech?.format ?? 'pcm';
+    const payload = {
+        model: resolveSpeechWireModel(req),
+        input: text,
+        response_format: format,
+    };
+    if (voice) {
+        payload.voice = voice;
+    }
+    return payload;
+}
+async function requestSpeech(apiKey, text, req, config) {
+    const fetchFn = config.fetch ?? fetch;
+    const baseUrl = config.baseUrl?.replace(/\/+$/, '') ?? 'https://openrouter.ai/api/v1';
+    const url = `${baseUrl}/audio/speech`;
+    return await fetchFn(url, {
+        method: 'POST',
+        headers: buildHeaders(apiKey, config),
+        body: JSON.stringify(buildPayload(req, text, req.speech, config.voice)),
+    });
+}
+function* yieldSpeechSuccess(rawBytes, text, format) {
+    let mediaMime = 'audio/mpeg';
+    let mediaBytes = rawBytes;
+    if (format === 'pcm') {
+        mediaMime = 'audio/wav';
+        mediaBytes = wrapPcmAsWav(rawBytes);
+    }
+    yield {
+        type: 'media',
+        media: { mimeType: mediaMime, data: bytesToBase64(mediaBytes) },
+    };
+    const inputTokens = Math.max(1, Math.round(text.length / 4));
+    const outputTokens = Math.max(1, Math.round(rawBytes.length / 100));
+    yield {
+        type: 'tokens',
+        tokens: { input: inputTokens, output: outputTokens, total: inputTokens + outputTokens },
+    };
+    yield { type: 'done' };
+}
+async function* streamSpeech(req, config = {}) {
+    const apiKey = config.apiKey?.trim() || undefined;
+    if (!apiKey) {
+        yield { type: 'error', error: publicError('missing API key for speech') };
+        return;
+    }
+    const text = extractInputText(req.input);
+    if (!text) {
+        yield { type: 'error', error: publicError('empty text for speech') };
+        return;
+    }
+    const res = await requestSpeech(apiKey, text, req, config);
+    if (res.status !== HTTP_OK) {
+        yield { type: 'error', error: publicError(`Speech HTTP ${String(res.status)}`) };
+        return;
+    }
+    const arrayBuffer = await res.arrayBuffer();
+    const rawBytes = new Uint8Array(arrayBuffer);
+    if (rawBytes.length === 0) {
+        yield { type: 'error', error: publicError('no audio returned from speech') };
+        return;
+    }
+    const format = req.speech?.format ?? 'pcm';
+    for (const ev of yieldSpeechSuccess(rawBytes, text, format)) {
+        yield ev;
+    }
+}
+/** Internal ModelProvider for openAi speech roles. */
+function createSpeechProvider(config = {}) {
+    return {
+        complete: (req) => streamSpeech(req, config),
+    };
+}
+export { createSpeechProvider, streamSpeech };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "theorum",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "description": "A flat TypeScript agent kernel for typed profiles, deterministic turn execution, dynamic tools, provider adapters, guardrails, and host-injected traces.",
   "keywords": [
     "agent",
@@ -26,23 +26,40 @@
       "import": "./esm/src/providers/mod.js"
     },
     "./openrouter": {
-      "import": "./esm/src/providers/openrouter.js"
+      "import": "./esm/src/providers/openrouter-mod.js"
     },
     "./guardrails": {
       "import": "./esm/src/guardrails/mod.js"
     },
     "./observability": {
       "import": "./esm/src/observability/mod.js"
+    },
+    "./host": {
+      "import": "./esm/src/host/mod.js"
+    },
+    "./cli": {
+      "import": "./esm/src/cli/index.js"
+    },
+    "./presets": {
+      "import": "./esm/src/presets/mod.js"
+    },
+    "./presets/google": {
+      "import": "./esm/src/presets/google.js"
     }
   },
   "scripts": {},
+  "bin": {
+    "theorum": "esm/src/cli/index.js"
+  },
   "type": "module",
   "sideEffects": false,
   "dependencies": {
+    "@openrouter/ai-sdk-provider": "1.5.4",
+    "ai": "5.0.244",
     "@deno/shim-deno": "~0.18.0"
   },
   "devDependencies": {
     "@types/node": "^20.9.0"
   },
   "_generatedBy": "dnt@0.43.2"
-}
+}

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

@@ -1,5 +0,0 @@
-import type { BuiltinToolId, ImageResponseFormat, InteractionPart, ModelId, Profile, TurnRequest } from '../kernel/types.js';
-declare function resolveImageFormat(profile: Profile, model: ModelId, slots?: Record<string, string>): ImageResponseFormat | null;
-declare function resolveInputParts(profile: Profile, model: ModelId, req: TurnRequest): InteractionPart[];
-declare function assertImageGrounding(model: ModelId, builtins: BuiltinToolId[]): void;
-export { assertImageGrounding, resolveImageFormat, resolveInputParts };

package/esm/src/providers/media.js

@@ -1,125 +0,0 @@
-import { TheorumError } from '../guardrails/error.js';
-import { wrapUserData } from '../kernel/engine/boundary.js';
-import { synthesizeRepairPrompt } from '../kernel/engine/repair.js';
-import { geminiKindForMime, mimeAllowed, mimeEssence, modelEntry, } from '../kernel/registry/catalog.js';
-import { assertAttachmentLimits, requireMediaLimits } from './attachments.js';
-function listedValue(allowed, requested) {
-    if (!requested) {
-        return allowed[0];
-    }
-    for (const item of allowed) {
-        if (item === requested) {
-            return item;
-        }
-    }
-    return undefined;
-}
-function requireImageSpec(profile, model) {
-    const spec = modelEntry(model).image;
-    if (!spec) {
-        throw new TheorumError(`Profile ${profile.id} requests media but ${model} is not an image model`);
-    }
-    if (profile.outputs.structured !== null) {
-        throw new TheorumError(`Profile ${profile.id} cannot mix structured JSON with native image output`);
-    }
-    return spec;
-}
-function resolveImageFormat(profile, model, slots) {
-    if (!profile.outputs.media) {
-        return null;
-    }
-    const spec = requireImageSpec(profile, model);
-    const aspectRatio = listedValue(spec.aspectRatios, slots?.aspectRatio);
-    const imageSize = listedValue(spec.sizes, slots?.imageSize);
-    if (!(aspectRatio && imageSize)) {
-        throw new TheorumError(`Unknown image aspect or size for ${profile.id}`);
-    }
-    return {
-        type: 'image',
-        mimeType: spec.outputMime,
-        aspectRatio,
-        imageSize,
-    };
-}
-function assertGeminiMime(mime) {
-    const kind = geminiKindForMime(mime);
-    if (!kind) {
-        throw new TheorumError(`MIME '${mime}' is not a Gemini input type`);
-    }
-    return kind;
-}
-function mediaParts(profile, model, blobs, channel) {
-    const accept = channel === 'voice' ? profile.inputs.voice?.accept : profile.inputs.attachments?.accept;
-    if (!accept) {
-        throw new TheorumError(`Profile ${profile.id} does not accept ${channel}`);
-    }
-    const spec = modelEntry(model).image;
-    const imageCount = blobs.filter((blob) => geminiKindForMime(blob.mimeType) === 'image').length;
-    if (spec && imageCount > spec.maxInputImages) {
-        throw new TheorumError(`At most ${spec.maxInputImages} reference images on ${model}`);
-    }
-    return blobs.map((blob) => {
-        const kind = assertGeminiMime(blob.mimeType);
-        if (!mimeAllowed(accept, blob.mimeType)) {
-            throw new TheorumError(`MIME '${blob.mimeType}' is not accepted on ${profile.id}`);
-        }
-        const essence = mimeEssence(blob.mimeType);
-        if (kind === 'image' && spec && !spec.inputMimes.includes(essence) && essence !== 'image/jpg') {
-            throw new TheorumError(`MIME '${blob.mimeType}' is not valid on ${model}`);
-        }
-        return {
-            type: kind,
-            mimeType: essence === 'image/jpg' ? 'image/jpeg' : essence,
-            data: blob.data,
-        };
-    });
-}
-function extractTextPart(profile, req) {
-    const { text, repair, history } = req.input ?? {};
-    if (profile.inputs.text === false) {
-        if (text) {
-            throw new TheorumError(`Profile ${profile.id} does not accept text input`);
-        }
-        return null;
-    }
-    let promptText = text;
-    if (repair) {
-        promptText = synthesizeRepairPrompt({ profile, repair, history });
-    }
-    if (!promptText) {
-        return null;
-    }
-    return { type: 'text', text: wrapUserData(promptText) };
-}
-function extractMediaParts(profile, model, req) {
-    const { attachments, voice } = req.input ?? {};
-    const files = attachments ?? [];
-    const clips = voice ?? [];
-    if (files.length + clips.length > 0) {
-        assertAttachmentLimits([...files, ...clips], requireMediaLimits(profile));
-    }
-    const parts = [];
-    if (files.length > 0) {
-        parts.push(...mediaParts(profile, model, files, 'attachments'));
-    }
-    if (clips.length > 0) {
-        parts.push(...mediaParts(profile, model, clips, 'voice'));
-    }
-    return parts;
-}
-function resolveInputParts(profile, model, req) {
-    const parts = [];
-    const textPart = extractTextPart(profile, req);
-    if (textPart) {
-        parts.push(textPart);
-    }
-    parts.push(...extractMediaParts(profile, model, req));
-    return parts;
-}
-function assertImageGrounding(model, builtins) {
-    const spec = modelEntry(model).image;
-    if (spec && !spec.allowsGrounding && builtins.length > 0) {
-        throw new TheorumError(`Grounding tools are not valid on ${model}`);
-    }
-}
-export { assertImageGrounding, resolveImageFormat, resolveInputParts };

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

@@ -1,24 +0,0 @@
-/**
- * OpenRouter TTS provider utilities.
- *
- * Provides direct text-to-speech streaming and a `ModelProvider` wrapper for
- * voice output profiles.
- *
- * @module
- */
-import type { ModelProvider, ProviderCompleteRequest, TurnEvent } from '../kernel/types.js';
-/** Wrap raw PCM bytes in a RIFF/WAVE container. */
-export declare function wrapPcmAsWav(pcm: Uint8Array, sampleRate?: number): Uint8Array;
-/** Host-supplied OpenRouter TTS configuration. */
-export interface OpenRouterTtsConfig {
-    apiKey?: string;
-    voiceName?: string;
-    baseUrl?: string;
-    siteUrl?: string;
-    siteName?: string;
-    fetch?: typeof fetch;
-}
-/** Stream one OpenRouter TTS synthesis request as THEORUM events. */
-export declare function streamOpenRouterTts(req: ProviderCompleteRequest, config?: OpenRouterTtsConfig): AsyncGenerator<TurnEvent>;
-/** Create a `ModelProvider` that emits TTS media events. */
-export declare function createOpenRouterTtsProvider(config?: OpenRouterTtsConfig): ModelProvider;

package/esm/src/providers/tts.js

@@ -1,144 +0,0 @@
-/**
- * OpenRouter TTS provider utilities.
- *
- * Provides direct text-to-speech streaming and a `ModelProvider` wrapper for
- * voice output profiles.
- *
- * @module
- */
-import { publicError } from '../guardrails/error.js';
-import { resolveOpenRouterApiKey } from './openrouter.js';
-const SAMPLE_RATE = 24000;
-const TTS_MODEL = 'google/gemini-3.1-flash-tts-preview';
-const HTTP_OK = 200;
-function bytesToBase64(bytes) {
-    let bin = '';
-    for (let i = 0; i < bytes.length; i++)
-        bin += String.fromCharCode(bytes[i]);
-    return btoa(bin);
-}
-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);
-}
-function extractInputText(input) {
-    return input
-        .filter((p) => p.type === 'text')
-        .map((p) => (p.type === 'text' ? p.text : ''))
-        .join(' ')
-        .trim();
-}
-function buildHeaders(apiKey, config) {
-    const headers = {
-        Authorization: `Bearer ${apiKey}`,
-        'Content-Type': 'application/json',
-    };
-    if (config.siteUrl) {
-        headers['HTTP-Referer'] = config.siteUrl;
-    }
-    if (config.siteName) {
-        headers['X-Title'] = config.siteName;
-    }
-    return headers;
-}
-function buildPayload(text, voiceSpec, configVoiceName) {
-    const voice = voiceSpec?.voice ?? configVoiceName;
-    const responseFormat = voiceSpec?.responseFormat ?? 'pcm';
-    const payload = {
-        model: TTS_MODEL,
-        input: text,
-        response_format: responseFormat,
-    };
-    if (voice) {
-        payload.voice = voice;
-    }
-    return payload;
-}
-async function requestTts(apiKey, text, req, config) {
-    const fetchFn = config.fetch ?? fetch;
-    const baseUrl = config.baseUrl?.replace(/\/+$/, '') ?? 'https://openrouter.ai/api/v1';
-    const url = `${baseUrl}/audio/speech`;
-    return await fetchFn(url, {
-        method: 'POST',
-        headers: buildHeaders(apiKey, config),
-        body: JSON.stringify(buildPayload(text, req.voice, config.voiceName)),
-    });
-}
-function* yieldTtsSuccess(rawBytes, text, responseFormat) {
-    let mediaMime = 'audio/mpeg';
-    let mediaBytes = rawBytes;
-    if (responseFormat === 'pcm') {
-        mediaMime = 'audio/wav';
-        mediaBytes = wrapPcmAsWav(rawBytes);
-    }
-    yield {
-        type: 'media',
-        media: { mimeType: mediaMime, data: bytesToBase64(mediaBytes) },
-    };
-    const inputTokens = Math.max(1, Math.round(text.length / 4));
-    const outputTokens = Math.max(1, Math.round(rawBytes.length / 100));
-    yield {
-        type: 'tokens',
-        tokens: { input: inputTokens, output: outputTokens, total: inputTokens + outputTokens },
-    };
-    yield { type: 'done' };
-}
-/** Stream one OpenRouter TTS synthesis request as THEORUM events. */
-export async function* streamOpenRouterTts(req, config = {}) {
-    const apiKey = resolveOpenRouterApiKey(config.apiKey);
-    if (!apiKey) {
-        yield { type: 'error', error: publicError('missing OpenRouter API key for TTS') };
-        return;
-    }
-    const text = extractInputText(req.input);
-    if (!text) {
-        yield { type: 'error', error: publicError('empty text for TTS') };
-        return;
-    }
-    const res = await requestTts(apiKey, text, req, config);
-    if (res.status !== HTTP_OK) {
-        yield { type: 'error', error: publicError(`OpenRouter TTS HTTP ${String(res.status)}`) };
-        return;
-    }
-    const arrayBuffer = await res.arrayBuffer();
-    const rawBytes = new Uint8Array(arrayBuffer);
-    if (rawBytes.length === 0) {
-        yield { type: 'error', error: publicError('no audio returned from TTS') };
-        return;
-    }
-    const responseFormat = req.voice?.responseFormat ?? 'pcm';
-    for (const ev of yieldTtsSuccess(rawBytes, text, responseFormat)) {
-        yield ev;
-    }
-}
-/** Create a `ModelProvider` that emits TTS media events. */
-export function createOpenRouterTtsProvider(config = {}) {
-    return {
-        complete: (req) => streamOpenRouterTts(req, config),
-    };
-}