@theoremjs/agents 0.3.0 → 0.3.2

package/esm/src/providers/openrouter/speech.js

@@ -1,109 +0,0 @@
-import { TheoremError, toErrorEvent } from '../../guardrails/error.js';
-import { bytesToBase64 } from '../../kernel/util/base64.js';
-import { mimeEssence } from '../../kernel/util/mime.js';
-import { pcmFormatFromMime, wrapPcmAsWav } from '../shared/pcm.js';
-import { networkFetch } from '../shared/upstream-tap.js';
-import { bearerFetch } from '../shared/vault.js';
-import { httpErrorEvent, openAiGatewayHeaders } from './openai/compat.js';
-import { resolveOpenAiGatewayApiKey } from './resolve-api-key.js';
-const HTTP_OK = 200;
-export function extractInputText(input) {
-    return input
-        .filter((p) => p.type === 'text')
-        .map((p) => (p.type === 'text' ? p.text : ''))
-        .join(' ')
-        .trim();
-}
-export function buildSpeechHeaders(apiKey, config) {
-    const headers = {
-        Authorization: `Bearer ${apiKey}`,
-        'Content-Type': 'application/json',
-    };
-    const gateway = openAiGatewayHeaders(config);
-    if (gateway)
-        Object.assign(headers, gateway);
-    return headers;
-}
-export function buildPayload(req, text, speech, configVoice) {
-    const voice = speech?.voice ?? configVoice;
-    const payload = {
-        model: req.apiId,
-        input: text,
-    };
-    if (speech?.format) {
-        payload.response_format = speech.format;
-    }
-    if (voice) {
-        payload.voice = voice;
-    }
-    return payload;
-}
-export async function requestSpeech(apiKey, text, req, config) {
-    const fetchFn = bearerFetch(req, networkFetch(config.fetch ?? fetch), config.vault, apiKey);
-    const baseUrl = config.baseUrl?.replace(/\/+$/, '') ?? 'https://openrouter.ai/api/v1';
-    const url = `${baseUrl}/audio/speech`;
-    return await fetchFn(url, {
-        method: 'POST',
-        headers: buildSpeechHeaders(apiKey, config),
-        body: JSON.stringify(buildPayload(req, text, req.speech, config.voice)),
-        signal: req.signal,
-    });
-}
-/**
- * The response's `content-type` states the audio (probe 23/09/2026:
- * `audio/pcm;rate=24000;channels=1` for `pcm`). Raw PCM with a stated rate is
- * wrapped as WAV; anything else keeps its reported type.
- */
-export function* yieldSpeechSuccess(rawBytes, contentType) {
-    const format = pcmFormatFromMime(contentType ?? '');
-    const media = format
-        ? { mimeType: 'audio/wav', data: bytesToBase64(wrapPcmAsWav(rawBytes, format)) }
-        : {
-            mimeType: mimeEssence(contentType ?? '') || 'application/octet-stream',
-            data: bytesToBase64(rawBytes),
-        };
-    yield { type: 'media', media };
-    // The endpoint answers whole or not at all: a body with audio completed.
-    yield { type: 'done', stop: { kind: 'completed' } };
-}
-export async function* streamSpeech(req, config = {}) {
-    let apiKey;
-    try {
-        apiKey = resolveOpenAiGatewayApiKey(config, req.keySlot);
-    }
-    catch (err) {
-        yield toErrorEvent(err);
-        return;
-    }
-    const text = extractInputText(req.input);
-    if (!text) {
-        yield toErrorEvent(new TheoremError('request', 'empty text for speech'));
-        return;
-    }
-    const res = await requestSpeech(apiKey, text, req, config);
-    if (res.status !== HTTP_OK) {
-        yield await httpErrorEvent(res, 'Speech');
-        return;
-    }
-    const arrayBuffer = await res.arrayBuffer();
-    const rawBytes = new Uint8Array(arrayBuffer);
-    const contentType = res.headers.get('content-type');
-    // The audio body as a tape row; the tape keeps its hash, not its bytes.
-    req.tapUpstream?.({
-        eventType: 'http_body',
-        mime_type: contentType ?? '',
-        data: bytesToBase64(rawBytes),
-    });
-    if (rawBytes.length === 0) {
-        yield toErrorEvent(new TheoremError('bad_response', 'no audio returned from speech'));
-        return;
-    }
-    for (const ev of yieldSpeechSuccess(rawBytes, contentType)) {
-        yield ev;
-    }
-}
-export function createSpeechProvider(config = {}) {
-    return {
-        complete: (req) => streamSpeech(req, config),
-    };
-}

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

@@ -1,5 +0,0 @@
-/**
- * With `THEOREM_IMPORT_PROBE=1`, lets subprocess tests assert adapters stay unloaded
- * until `complete` runs. Only `create-provider.ts` may call it.
- */
-export declare function markModuleLoad(label: string): void;

package/esm/src/providers/probe.js

@@ -1,15 +0,0 @@
-/**
- * With `THEOREM_IMPORT_PROBE=1`, lets subprocess tests assert adapters stay unloaded
- * until `complete` runs. Only `create-provider.ts` may call it.
- */
-export function markModuleLoad(label) {
-    try {
-        const d = globalThis.Deno;
-        if (d?.env?.get('THEOREM_IMPORT_PROBE') === '1' && d.stdout?.writeSync) {
-            d.stdout.writeSync(new TextEncoder().encode(`LOADED:${label}\n`));
-        }
-    }
-    catch {
-        // Non-Deno runtime or missing --allow-env.
-    }
-}

package/esm/src/providers/shared/builtin-wire.d.ts

@@ -1,4 +0,0 @@
-import type { BuiltinWire } from '../../kernel/tools/types.js';
-import type { ProviderBuiltin } from '../../kernel/types.js';
-declare function builtinWire(builtin: ProviderBuiltin, transport: keyof BuiltinWire): string;
-export { builtinWire };

package/esm/src/providers/shared/builtin-wire.js

@@ -1,9 +0,0 @@
-import { TheoremError } from '../../guardrails/error.js';
-function builtinWire(builtin, transport) {
-    const wire = builtin.wire[transport];
-    if (!wire) {
-        throw new TheoremError('config', `Builtin '${builtin.id}' has no wire.${transport}`); // lexicon-exempt: developer contract / internal diagnostic — not end-user or model copy (P2)
-    }
-    return wire;
-}
-export { builtinWire };

package/esm/src/providers/shared/vault.d.ts

@@ -1,13 +0,0 @@
-import type { KeySlot, KeyVault, ProviderCompleteRequest } from '../../kernel/types.js';
-/** The key in `slot`. One vault serves every provider; a slot holds whatever secret the host put there. */
-export declare function requireKey(vault: KeyVault | undefined, slot: KeySlot): string;
-/** The profile's fallback slot and its key, when the vault holds a different key there. */
-export declare function fallbackKey(slot: KeySlot | undefined, vault: KeyVault | undefined, primary: string): {
-    slot: KeySlot;
-    key: string;
-} | undefined;
-/**
- * A tapped fetch for a provider that takes a bearer token. A quota refusal retries once with the
- * fallback slot's key, when the profile names one; each try's slot is on the tape.
- */
-export declare function bearerFetch(req: Pick<ProviderCompleteRequest, 'tapUpstream' | 'keySlot' | 'fallbackKeySlot'>, send: typeof fetch, vault: KeyVault | undefined, primary: string): typeof fetch;

package/esm/src/providers/shared/vault.js

@@ -1,41 +0,0 @@
-import { TheoremError } from '../../guardrails/error.js';
-import { tapFetch } from './upstream-tap.js';
-const HTTP_QUOTA = 429;
-/** The key in `slot`. One vault serves every provider; a slot holds whatever secret the host put there. */
-export function requireKey(vault, slot) {
-    const key = vault?.[slot]?.trim();
-    if (!key) {
-        throw new TheoremError('auth', `the vault has no key in slot '${slot}'`);
-    }
-    return key;
-}
-/** The profile's fallback slot and its key, when the vault holds a different key there. */
-export function fallbackKey(slot, vault, primary) {
-    const key = slot ? vault?.[slot]?.trim() : undefined;
-    if (!slot || !key || key === primary) {
-        return undefined;
-    }
-    return { slot, key };
-}
-/**
- * A tapped fetch for a provider that takes a bearer token. A quota refusal retries once with the
- * fallback slot's key, when the profile names one; each try's slot is on the tape.
- */
-export function bearerFetch(req, send, vault, primary) {
-    const first = tapFetch(req.tapUpstream, send, req.keySlot);
-    const fallback = req.keySlot ? fallbackKey(req.fallbackKeySlot, vault, primary) : undefined;
-    if (!fallback) {
-        return first;
-    }
-    const second = tapFetch(req.tapUpstream, send, fallback.slot);
-    return async (url, init) => {
-        const res = await first(url, init);
-        if (res.status !== HTTP_QUOTA) {
-            return res;
-        }
-        await res.body?.cancel();
-        const headers = new Headers(init?.headers);
-        headers.set('Authorization', `Bearer ${fallback.key}`);
-        return await second(url, { ...init, headers });
-    };
-}