theorum 0.1.6 → 0.1.9

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

@@ -7,9 +7,126 @@
  *
  * @module
  */
-import type { ModelProvider } from '../kernel/types.js';
+import { createOpenRouter, type OpenRouterChatSettings } from '@openrouter/ai-sdk-provider';
+import { type LanguageModelUsage, type ModelMessage, streamText, type TextStreamPart, type ToolSet } from 'ai';
+import type { DynamicToolDeclaration, InteractionPart, ModelProvider, ProviderCompleteRequest, TurnEvent, TurnHistoryMessage, TurnTokens } from '../kernel/types.js';
 import { type OpenRouterConfig, resolveOpenRouterModel, toOpenRouterPayload } from './openrouter-payload.js';
+interface StreamAccumulator {
+    text: string;
+    evidenceSeen: boolean;
+    emittedTokens: boolean;
+    errored: boolean;
+}
+interface OpenRouterStreamContext {
+    openrouter: ReturnType<typeof createOpenRouter>;
+    modelName: string;
+}
+type JsonValue = string | number | boolean | null | JsonValue[] | {
+    [key: string]: JsonValue;
+};
+type ProviderOptions = Record<string, {
+    [key: string]: JsonValue;
+}>;
+declare function trimApiKey(explicitKey?: string): string | undefined;
+declare function createAccumulator(): StreamAccumulator;
+declare function mediaPart(part: InteractionPart): Record<string, unknown>;
+declare function contentFromParts(parts: InteractionPart[]): string | Array<Record<string, unknown>>;
+declare function parseToolInput(raw: string): unknown;
+declare function stringDefault(value: string | undefined, fallback: string): string;
+declare function fallbackToolCallId(name?: string): string;
+declare function toolResultContent(msg: TurnHistoryMessage): ModelMessage;
+declare function assistantToolCallContent(msg: TurnHistoryMessage): ModelMessage | null;
+declare function historyMessage(msg: TurnHistoryMessage): ModelMessage | null;
+declare function contentFromOptionalParts(parts: InteractionPart[] | undefined, text: string | undefined): string | Array<Record<string, unknown>>;
+declare function contentHistoryMessage(msg: TurnHistoryMessage): ModelMessage;
+declare function sourceEvent(part: Extract<TextStreamPart<ToolSet>, {
+    type: 'source';
+}>): TurnEvent;
+declare function buildMessages(req: ProviderCompleteRequest): ModelMessage[];
+declare function schemaForTool(decl: DynamicToolDeclaration): Record<string, unknown>;
+declare function buildTools(dynamicTools?: DynamicToolDeclaration[]): ToolSet | undefined;
+declare function openRouterSettings(req: ProviderCompleteRequest): OpenRouterChatSettings | undefined;
+declare function tokensFromUsage(usage: LanguageModelUsage): TurnTokens | undefined;
+declare function rawRecord(value: unknown): Record<string, unknown> | undefined;
+declare function stringArray(value: unknown): string[] | undefined;
+declare function metadataRecord(raw: Record<string, unknown>, key: string): Record<string, unknown> | undefined;
+declare function citationCandidates(raw: Record<string, unknown>): unknown[];
+declare function nestedCitations(raw: Record<string, unknown>): string[] | undefined;
+declare function metadataAnnotations(raw: Record<string, unknown>): unknown[] | undefined;
+declare function evidenceFromMetadata(metadata: unknown, acc: StreamAccumulator): TurnEvent | undefined;
+declare function toolArguments(input: unknown): Record<string, unknown> | undefined;
+declare function toolResultData(output: unknown): Record<string, unknown> | undefined;
+declare function rawThoughtEvent(raw: Record<string, unknown>): TurnEvent | undefined;
+declare function rawChoiceMessageEvidence(raw: Record<string, unknown>, acc: StreamAccumulator): TurnEvent | undefined;
+declare function rawEvents(raw: unknown, acc: StreamAccumulator): TurnEvent[];
+declare function toolCallEvent(part: Extract<TextStreamPart<ToolSet>, {
+    type: 'tool-call';
+}>): TurnEvent;
+declare function toolResultEvent(part: Extract<TextStreamPart<ToolSet>, {
+    type: 'tool-result';
+}>): TurnEvent;
+declare function tokenEvent(part: Extract<TextStreamPart<ToolSet>, {
+    type: 'finish';
+}>): TurnEvent | undefined;
+declare function providerMetadataEvent(part: TextStreamPart<ToolSet>, acc: StreamAccumulator): TurnEvent | undefined;
+declare function eventFromPart(part: TextStreamPart<ToolSet>, acc: StreamAccumulator): TurnEvent[];
+declare function primaryEventFromPart(part: TextStreamPart<ToolSet>, acc: StreamAccumulator): TurnEvent | undefined;
+declare function finishEvent(part: Extract<TextStreamPart<ToolSet>, {
+    type: 'finish';
+}>, acc: StreamAccumulator): TurnEvent | undefined;
+declare function streamTextOptions(req: ProviderCompleteRequest, context: OpenRouterStreamContext): Parameters<typeof streamText>[0];
+declare function missingOpenRouterKey(): TurnEvent;
+declare function finalEvents(req: ProviderCompleteRequest, acc: StreamAccumulator): Generator<TurnEvent>;
+declare function responseFormatFor(req: ProviderCompleteRequest): Record<string, JsonValue> | undefined;
+declare function providerOptionsFor(req: ProviderCompleteRequest): ProviderOptions | undefined;
+declare function openRouterHeaders(config: OpenRouterConfig): Record<string, string> | undefined;
 /** Create a `ModelProvider` backed by OpenRouter through AI SDK Core. */
 declare function createOpenRouterProvider(config?: OpenRouterConfig): ModelProvider;
 export type { OpenRouterConfig };
 export { createOpenRouterProvider, resolveOpenRouterModel, toOpenRouterPayload };
+/** @internal Exported for direct unit testing only. */
+export declare const _internals: {
+    trimApiKey: typeof trimApiKey;
+    createAccumulator: typeof createAccumulator;
+    mediaPart: typeof mediaPart;
+    contentFromParts: typeof contentFromParts;
+    parseToolInput: typeof parseToolInput;
+    stringDefault: typeof stringDefault;
+    fallbackToolCallId: typeof fallbackToolCallId;
+    toolResultContent: typeof toolResultContent;
+    assistantToolCallContent: typeof assistantToolCallContent;
+    historyMessage: typeof historyMessage;
+    contentFromOptionalParts: typeof contentFromOptionalParts;
+    contentHistoryMessage: typeof contentHistoryMessage;
+    buildMessages: typeof buildMessages;
+    schemaForTool: typeof schemaForTool;
+    buildTools: typeof buildTools;
+    openRouterSettings: typeof openRouterSettings;
+    tokensFromUsage: typeof tokensFromUsage;
+    rawRecord: typeof rawRecord;
+    stringArray: typeof stringArray;
+    metadataRecord: typeof metadataRecord;
+    citationCandidates: typeof citationCandidates;
+    nestedCitations: typeof nestedCitations;
+    metadataAnnotations: typeof metadataAnnotations;
+    evidenceFromMetadata: typeof evidenceFromMetadata;
+    toolArguments: typeof toolArguments;
+    toolResultData: typeof toolResultData;
+    rawThoughtEvent: typeof rawThoughtEvent;
+    rawChoiceMessageEvidence: typeof rawChoiceMessageEvidence;
+    rawEvents: typeof rawEvents;
+    toolCallEvent: typeof toolCallEvent;
+    toolResultEvent: typeof toolResultEvent;
+    tokenEvent: typeof tokenEvent;
+    providerMetadataEvent: typeof providerMetadataEvent;
+    eventFromPart: typeof eventFromPart;
+    primaryEventFromPart: typeof primaryEventFromPart;
+    finishEvent: typeof finishEvent;
+    sourceEvent: typeof sourceEvent;
+    finalEvents: typeof finalEvents;
+    responseFormatFor: typeof responseFormatFor;
+    providerOptionsFor: typeof providerOptionsFor;
+    openRouterHeaders: typeof openRouterHeaders;
+    missingOpenRouterKey: typeof missingOpenRouterKey;
+    streamTextOptions: typeof streamTextOptions;
+};

package/esm/src/providers/openrouter.js

@@ -9,11 +9,10 @@
  */
 import { createOpenRouter } from '@openrouter/ai-sdk-provider';
 import { jsonSchema, streamText, tool, } from 'ai';
-import { toErrorEvent } from '../guardrails/error.js';
+import { isAbortError, toErrorEvent } 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';
+import { getStructured } from '../kernel/registry/schemas.js';
+import { resolveOpenRouterModel, resolveOpenRouterPlugins, toOpenRouterPayload, } from './openrouter-payload.js';
 function trimApiKey(explicitKey) {
     if (explicitKey?.trim()) {
         return explicitKey.trim();
@@ -26,7 +25,6 @@ function createAccumulator() {
         evidenceSeen: false,
         emittedTokens: false,
         errored: false,
-        toolInputs: new Map(),
     };
 }
 function mediaPart(part) {
@@ -61,9 +59,6 @@ function parseToolInput(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')}`;
 }
@@ -111,34 +106,21 @@ 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);
+    if (part.sourceType !== 'url') {
+        return {
+            type: 'evidence',
+            evidence: { provider: 'openrouter', raw: part },
+        };
+    }
+    const title = part.title ?? part.url;
     return {
         type: 'evidence',
         evidence: {
             provider: 'openrouter',
-            raw,
-            citations: optionalSingle(url),
-            sources: sourceList(title, url),
+            raw: part,
+            citations: [part.url],
+            sources: [{ title, uri: part.url, type: 'web' }],
         },
     };
 }
@@ -171,19 +153,17 @@ function buildTools(dynamicTools) {
     }
     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) {
+    const { plugins, webSearch } = resolveOpenRouterPlugins(req.builtins);
+    if (plugins.length === 0 && !webSearch) {
         return undefined;
     }
-    return { plugins };
+    const settings = {};
+    if (plugins.length > 0)
+        settings.plugins = plugins;
+    if (webSearch)
+        settings.web_search_options = {};
+    return settings;
 }
 function tokensFromUsage(usage) {
     const input = usage.inputTokens ?? 0;
@@ -269,17 +249,6 @@ function toolArguments(input) {
     }
     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);
 }
@@ -333,45 +302,12 @@ function rawEvents(raw, acc) {
     }
     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) {
+function toolCallEvent(part) {
     return {
         type: 'tool',
         tool: {
             name: part.toolName,
-            arguments: toolCallArguments(part, acc),
+            arguments: toolArguments(part.input),
             id: part.toolCallId,
         },
     };
@@ -401,22 +337,7 @@ function providerMetadataEvent(part, acc) {
     }
     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];
@@ -432,11 +353,15 @@ function primaryEventFromPart(part, acc) {
         case 'reasoning-delta':
             return { type: 'thought', text: part.text };
         case 'tool-call':
-            return toolCallEvent(part, acc);
+            return toolCallEvent(part);
         case 'tool-result':
             return toolResultEvent(part);
-        case 'source':
+        case 'source': {
+            if (acc.evidenceSeen)
+                return undefined;
+            acc.evidenceSeen = true;
             return sourceEvent(part);
+        }
         case 'finish':
             return finishEvent(part, acc);
         case 'error':
@@ -456,27 +381,12 @@ function finishEvent(part, acc) {
     }
     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;
-        }),
+        fetch: config.fetch,
         compatibility: 'strict',
     });
     return {
@@ -485,26 +395,26 @@ function createStreamContext(req, config, apiKey) {
             apiId: req.apiId,
             openRouterId: req.openRouterId,
         }),
-        rawCapture: () => rawCapture,
     };
 }
 function streamTextOptions(req, context) {
     return {
         model: context.openrouter.chat(context.modelName, openRouterSettings(req)),
-        system: req.system,
+        instructions: req.system,
         messages: buildMessages(req),
         allowSystemInMessages: true,
         temperature: req.temperature,
         maxOutputTokens: req.maxOutputTokens,
         tools: buildTools(req.dynamicTools),
         providerOptions: providerOptionsFor(req),
-        includeRawChunks: true,
+        include: { rawChunks: true },
+        abortSignal: req.signal,
         onError: () => undefined,
     };
 }
 async function* yieldAiSdkStream(req, acc, context) {
     const result = streamText(streamTextOptions(req, context));
-    for await (const part of result.fullStream) {
+    for await (const part of result.stream) {
         if (part.type === 'raw') {
             req.tapGemini?.(rawRecord(part.rawValue) ?? { rawValue: part.rawValue });
             for (const event of rawEvents(part.rawValue, acc)) {
@@ -517,16 +427,6 @@ async function* yieldAiSdkStream(req, acc, context) {
         }
     }
 }
-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 toErrorEvent('missing OpenRouter API key');
 }
@@ -540,11 +440,12 @@ async function* streamOpenRouter(req, config) {
     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);
+        if (isAbortError(err)) {
+            throw err;
+        }
         yield toErrorEvent(err);
     }
 }
@@ -560,16 +461,34 @@ function* finalEvents(req, acc) {
     }
     yield { type: 'done' };
 }
-function providerOptionsFor(req) {
-    if (req.thinking === 'none') {
+function responseFormatFor(req) {
+    if (!req.structured)
+        return undefined;
+    const spec = getStructured(req.structured);
+    if (!spec.jsonSchema)
         return undefined;
-    }
     return {
-        openrouter: {
-            reasoning: { effort: req.thinking },
+        type: 'json_schema',
+        json_schema: {
+            name: String(req.structured),
+            strict: true,
+            schema: spec.jsonSchema,
         },
     };
 }
+function providerOptionsFor(req) {
+    const openrouter = {};
+    if (req.thinking !== 'none') {
+        openrouter.reasoning = { effort: req.thinking };
+    }
+    const responseFormat = responseFormatFor(req);
+    if (responseFormat) {
+        openrouter.response_format = responseFormat;
+    }
+    if (Object.keys(openrouter).length === 0)
+        return undefined;
+    return { openrouter };
+}
 function openRouterHeaders(config) {
     const headers = {};
     if (config.siteUrl) {
@@ -587,3 +506,49 @@ function createOpenRouterProvider(config = {}) {
     };
 }
 export { createOpenRouterProvider, resolveOpenRouterModel, toOpenRouterPayload };
+/** @internal Exported for direct unit testing only. */
+export const _internals = {
+    trimApiKey,
+    createAccumulator,
+    mediaPart,
+    contentFromParts,
+    parseToolInput,
+    stringDefault,
+    fallbackToolCallId,
+    toolResultContent,
+    assistantToolCallContent,
+    historyMessage,
+    contentFromOptionalParts,
+    contentHistoryMessage,
+    buildMessages,
+    schemaForTool,
+    buildTools,
+    openRouterSettings,
+    tokensFromUsage,
+    rawRecord,
+    stringArray,
+    metadataRecord,
+    citationCandidates,
+    nestedCitations,
+    metadataAnnotations,
+    evidenceFromMetadata,
+    toolArguments,
+    toolResultData,
+    rawThoughtEvent,
+    rawChoiceMessageEvidence,
+    rawEvents,
+    toolCallEvent,
+    toolResultEvent,
+    tokenEvent,
+    providerMetadataEvent,
+    eventFromPart,
+    primaryEventFromPart,
+    finishEvent,
+    sourceEvent,
+    finalEvents,
+    responseFormatFor,
+    providerOptionsFor,
+    openRouterHeaders,
+    missingOpenRouterKey,
+    streamTextOptions,
+};

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

@@ -3,5 +3,12 @@
  *
  * @module
  */
+declare function writeAscii(view: DataView, offset: number, str: string): void;
 /** Wrap raw PCM bytes in a RIFF/WAVE container. */
 export declare function wrapPcmAsWav(pcm: Uint8Array, sampleRate?: number): Uint8Array;
+/** @internal Exported for direct unit testing only. */
+export declare const _internals: {
+    writeAscii: typeof writeAscii;
+    wrapPcmAsWav: typeof wrapPcmAsWav;
+};
+export {};

package/esm/src/providers/pcm.js

@@ -33,3 +33,5 @@ export function wrapPcmAsWav(pcm, sampleRate = SAMPLE_RATE) {
     new Uint8Array(buf, 44).set(pcm);
     return new Uint8Array(buf);
 }
+/** @internal Exported for direct unit testing only. */
+export const _internals = { writeAscii, wrapPcmAsWav };

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

@@ -8,8 +8,36 @@
  *
  * @module
  */
-import type { ModelProvider } from '../kernel/types.js';
+import type { ModelProvider, ProviderCompleteRequest, TurnEvent } from '../kernel/types.js';
 import { type GeminiTransport } from './keys.js';
+declare function base64ToBytes(data: string): Uint8Array;
+declare function bytesToBase64(bytes: Uint8Array): string;
+declare function isRawPcmMime(mime: string): boolean;
+/** Google TTS returns raw PCM; wrap as WAV for hosts (matches OpenRouter pcm path). */
+declare function normalizeSpeechMedia(event: TurnEvent, speech: boolean): TurnEvent;
+declare function eventType(event: Record<string, unknown>): string;
+declare function isDeltaEvent(kind: string): boolean;
+declare function isCompleteEvent(kind: string): boolean;
+declare function foldDeltaPayload(event: Record<string, unknown>, acc: {
+    text: string;
+}): TurnEvent[];
+declare function foldPayload(event: Record<string, unknown>, acc: {
+    text: string;
+}): TurnEvent[];
+declare function withTap(req: ProviderCompleteRequest, transport: GeminiTransport): GeminiTransport;
 /** Create a `ModelProvider` backed by Google Interactions streaming. */
 declare function createInteractionsProvider(transport: GeminiTransport): ModelProvider;
 export { createInteractionsProvider };
+/** @internal Exported for direct unit testing only. */
+export declare const _internals: {
+    base64ToBytes: typeof base64ToBytes;
+    bytesToBase64: typeof bytesToBase64;
+    isRawPcmMime: typeof isRawPcmMime;
+    normalizeSpeechMedia: typeof normalizeSpeechMedia;
+    eventType: typeof eventType;
+    isDeltaEvent: typeof isDeltaEvent;
+    isCompleteEvent: typeof isCompleteEvent;
+    foldDeltaPayload: typeof foldDeltaPayload;
+    foldPayload: typeof foldPayload;
+    withTap: typeof withTap;
+};

package/esm/src/providers/provider.js

@@ -8,7 +8,7 @@
  *
  * @module
  */
-import { TheorumError, toErrorEvent } from '../guardrails/error.js';
+import { isAbortError, TheorumError, toErrorEvent } from '../guardrails/error.js';
 import { eventsFromComplete, eventsFromDelta, extractTokenEvent, groundingFromEvent, tryStructured, } from '../kernel/engine/delta.js';
 import { tapFetch } from './google-tap.js';
 import { toInteractionsBody } from './interactions.js';
@@ -121,7 +121,7 @@ async function* streamComplete(req, transport) {
         yield toErrorEvent('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));
+    const res = await fetchGemini(INTERACTIONS_URL, { method: 'POST', body: JSON.stringify(toInteractionsBody(req)), signal: req.signal }, req.geminiBucket, withTap(req, transport));
     if (res.status !== HTTP_OK) {
         const errorBody = await res.text().catch(() => '');
         yield toErrorEvent(`Gemini HTTP ${String(res.status)}: ${errorBody}`);
@@ -148,6 +148,9 @@ async function* streamGuarded(req, transport) {
         yield* streamComplete(req, transport);
     }
     catch (err) {
+        if (isAbortError(err)) {
+            throw err;
+        }
         yield toErrorEvent(err);
     }
 }
@@ -158,3 +161,16 @@ function createInteractionsProvider(transport) {
     };
 }
 export { createInteractionsProvider };
+/** @internal Exported for direct unit testing only. */
+export const _internals = {
+    base64ToBytes,
+    bytesToBase64,
+    isRawPcmMime,
+    normalizeSpeechMedia,
+    eventType,
+    isDeltaEvent,
+    isCompleteEvent,
+    foldDeltaPayload,
+    foldPayload,
+    withTap,
+};

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

@@ -6,7 +6,8 @@
  *
  * @module
  */
-import type { ModelProvider, ProviderCompleteRequest, TurnEvent } from '../kernel/types.js';
+import type { InteractionPart, ModelProvider, ProfileSpeechSpec, ProviderCompleteRequest, SpeechAudioFormat, TurnEvent } from '../kernel/types.js';
+declare function bytesToBase64(bytes: Uint8Array): string;
 /** Credentials for the openAi speech path (same shape as OpenRouter chat config + voice). */
 export interface SpeechProviderConfig {
     apiKey?: string;
@@ -17,7 +18,23 @@ export interface SpeechProviderConfig {
     siteName?: string;
     fetch?: typeof fetch;
 }
+declare function extractInputText(input: InteractionPart[]): string;
+declare function resolveSpeechWireModel(req: ProviderCompleteRequest): string;
+declare function buildHeaders(apiKey: string, config: SpeechProviderConfig): Record<string, string>;
+declare function buildPayload(req: ProviderCompleteRequest, text: string, speech: ProfileSpeechSpec | undefined, configVoice?: string): Record<string, unknown>;
+declare function requestSpeech(apiKey: string, text: string, req: ProviderCompleteRequest, config: SpeechProviderConfig): Promise<Response>;
+declare function yieldSpeechSuccess(rawBytes: Uint8Array, text: string, format: SpeechAudioFormat): Generator<TurnEvent>;
 declare function streamSpeech(req: ProviderCompleteRequest, config?: SpeechProviderConfig): AsyncGenerator<TurnEvent>;
 /** Internal ModelProvider for openAi speech roles. */
 declare function createSpeechProvider(config?: SpeechProviderConfig): ModelProvider;
 export { createSpeechProvider, streamSpeech };
+/** @internal Exported for direct unit testing only. */
+export declare const _internals: {
+    bytesToBase64: typeof bytesToBase64;
+    extractInputText: typeof extractInputText;
+    resolveSpeechWireModel: typeof resolveSpeechWireModel;
+    buildHeaders: typeof buildHeaders;
+    buildPayload: typeof buildPayload;
+    requestSpeech: typeof requestSpeech;
+    yieldSpeechSuccess: typeof yieldSpeechSuccess;
+};

package/esm/src/providers/speech.js

@@ -68,6 +68,7 @@ async function requestSpeech(apiKey, text, req, config) {
         method: 'POST',
         headers: buildHeaders(apiKey, config),
         body: JSON.stringify(buildPayload(req, text, req.speech, config.voice)),
+        signal: req.signal,
     });
 }
 function* yieldSpeechSuccess(rawBytes, text, format) {
@@ -123,3 +124,13 @@ function createSpeechProvider(config = {}) {
     };
 }
 export { createSpeechProvider, streamSpeech };
+/** @internal Exported for direct unit testing only. */
+export const _internals = {
+    bytesToBase64,
+    extractInputText,
+    resolveSpeechWireModel,
+    buildHeaders,
+    buildPayload,
+    requestSpeech,
+    yieldSpeechSuccess,
+};