theorum 0.1.15 → 1.1.3

package/esm/src/providers/google/live/session.js

@@ -0,0 +1,134 @@
+/**
+ * Google Gemini Live session transport — long-lived BidiGenerateContent WebSocket.
+ *
+ * `turnComplete` is a conversational turn boundary, not session teardown.
+ *
+ * @module
+ */
+import { isAbortError, TheorumError } from '../../../guardrails/error.js';
+import { requireKey } from '../keys.js';
+import { buildGeminiLiveWebSocketUrl } from './framing.js';
+import { attachLiveSessionHandlers, createLiveQueue, performLiveSetup, sendInitialPayloads, } from './stream.js';
+function defaultOpenWebSocket(url) {
+    return Promise.resolve(new WebSocket(url));
+}
+function attachAbort(ws, liveQueue, signal) {
+    const onAbort = () => {
+        if (!liveQueue.isClosed()) {
+            liveQueue.close();
+            try {
+                ws.close(1000, 'aborted');
+            }
+            catch {
+                // Ignore
+            }
+            liveQueue.push({
+                type: 'error',
+                error: new DOMException('The operation was aborted.', 'AbortError'),
+            });
+        }
+    };
+    if (!signal) {
+        return () => { };
+    }
+    if (signal.aborted) {
+        onAbort();
+        return () => { };
+    }
+    signal.addEventListener('abort', onAbort, { once: true });
+    return () => signal.removeEventListener('abort', onAbort);
+}
+/**
+ * Open a long-lived Gemini Live WebSocket after setup handshake.
+ * Callers own send / batch drain / close — typically via `runSession`.
+ *
+ * @param openWebSocket Host override for Cloudflare fetch-upgrade (etc.).
+ */
+export async function openGoogleLiveSession(req, transport, openWebSocket = defaultOpenWebSocket) {
+    if (!req.keySlot) {
+        throw new TheorumError('Request requires keySlot');
+    }
+    const apiKey = requireKey(transport.vault, req.keySlot);
+    const wsUrl = buildGeminiLiveWebSocketUrl(apiKey);
+    let ws;
+    try {
+        ws = await openWebSocket(wsUrl);
+    }
+    catch (err) {
+        throw err instanceof Error ? err : new Error(String(err));
+    }
+    const liveQueue = createLiveQueue();
+    const detachAbort = attachAbort(ws, liveQueue, req.signal);
+    if (req.signal?.aborted) {
+        detachAbort();
+        try {
+            ws.close();
+        }
+        catch {
+            // Ignore
+        }
+        throw new DOMException('The operation was aborted.', 'AbortError');
+    }
+    try {
+        await performLiveSetup(ws, req);
+    }
+    catch (err) {
+        detachAbort();
+        try {
+            ws.close();
+        }
+        catch {
+            // Ignore
+        }
+        throw err;
+    }
+    attachLiveSessionHandlers(ws, liveQueue);
+    sendInitialPayloads(ws, req);
+    return {
+        send(payload) {
+            if (ws.readyState === WebSocket.OPEN) {
+                ws.send(payload);
+            }
+        },
+        async *batches() {
+            try {
+                while (true) {
+                    const item = await liveQueue.next();
+                    if (!item)
+                        break;
+                    if (item.type === 'error' && isAbortError(item.error)) {
+                        throw item.error;
+                    }
+                    yield item;
+                    if (item.type === 'closed' || item.type === 'error') {
+                        break;
+                    }
+                }
+            }
+            finally {
+                detachAbort();
+                liveQueue.close();
+                try {
+                    if (ws.readyState === WebSocket.OPEN || ws.readyState === WebSocket.CONNECTING) {
+                        ws.close(1000, 'session-closed');
+                    }
+                }
+                catch {
+                    // Ignore
+                }
+            }
+        },
+        close(code = 1000, reason = 'session-closed') {
+            detachAbort();
+            liveQueue.close();
+            try {
+                if (ws.readyState === WebSocket.OPEN || ws.readyState === WebSocket.CONNECTING) {
+                    ws.close(code, reason);
+                }
+            }
+            catch {
+                // Ignore
+            }
+        },
+    };
+}

package/esm/src/providers/google/live/stream.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Shared Gemini Live WebSocket transport helpers.
+ *
+ * Used by `openGoogleLiveSession` / `runSession`. No ModelProvider.complete() path —
+ * live is session-scoped, not turn-scoped.
+ *
+ * @module
+ */
+import type { ProviderCompleteRequest, TurnEvent } from '../../../kernel/types.js';
+export type LiveTurnPhase = 'streaming' | 'complete' | 'abort';
+export type SessionQueueItem = {
+    type: 'batch';
+    events: TurnEvent[];
+    turnPhase: LiveTurnPhase;
+} | {
+    type: 'error';
+    error: Error;
+} | {
+    type: 'closed';
+};
+export declare function readMessageData(data: unknown): Promise<string>;
+export declare function readGeminiLiveErrorMessage(message: Record<string, unknown>): string | null;
+export declare function performLiveSetup(ws: WebSocket, req: ProviderCompleteRequest): Promise<void>;
+export type LiveSocketSender = {
+    send(data: string): void;
+};
+export declare function sendInitialPayloads(ws: LiveSocketSender, req: ProviderCompleteRequest): void;
+export interface LiveQueue {
+    push: (item: SessionQueueItem) => void;
+    next: () => Promise<SessionQueueItem | undefined>;
+    close: () => void;
+    isClosed: () => boolean;
+}
+export declare function createLiveQueue(): LiveQueue;
+/**
+ * Conversational cycle boundary.
+ *
+ * When the server reports `interactionStatus`, that is authoritative: `IDLE`
+ * closes the cycle and `IN_PROGRESS` keeps it open even across `turnComplete`
+ * (background reasoning / async tools may still produce output). Without the
+ * field, `turnComplete` is the boundary as before.
+ */
+export declare function turnPhaseFromMessage(message: Record<string, unknown>, events: TurnEvent[]): LiveTurnPhase;
+/** Attach handlers that keep the socket open across conversational turns. */
+export declare function attachLiveSessionHandlers(ws: WebSocket, liveQueue: LiveQueue): void;

package/esm/src/providers/google/live/stream.js

@@ -0,0 +1,214 @@
+/**
+ * Shared Gemini Live WebSocket transport helpers.
+ *
+ * Used by `openGoogleLiveSession` / `runSession`. No ModelProvider.complete() path —
+ * live is session-scoped, not turn-scoped.
+ *
+ * @module
+ */
+import { TheorumError } from '../../../guardrails/error.js';
+import { buildGeminiLiveClientContent, buildGeminiLiveRealtimeInput, buildGeminiLiveSetupMessage, foldGeminiLiveServerMessage, parseGeminiLiveMessage, readLiveInteractionStatus, } from './framing.js';
+const SETUP_TIMEOUT_MS = 20_000;
+export async function readMessageData(data) {
+    if (typeof data === 'string')
+        return data;
+    if (data instanceof ArrayBuffer) {
+        return new TextDecoder().decode(data);
+    }
+    if (typeof Blob !== 'undefined' && data instanceof Blob) {
+        return await data.text();
+    }
+    return String(data);
+}
+export function readGeminiLiveErrorMessage(message) {
+    const error = message.error;
+    if (!error || typeof error !== 'object')
+        return null;
+    const record = error;
+    if (typeof record.message === 'string' && record.message.length > 0) {
+        const status = typeof record.status === 'string' ? record.status : null;
+        return status ? `${status}: ${record.message}` : record.message;
+    }
+    return 'Gemini returned an error during live session.';
+}
+export function performLiveSetup(ws, req) {
+    return new Promise((resolve, reject) => {
+        let setupResolved = false;
+        const timeout = setTimeout(() => {
+            if (!setupResolved) {
+                setupResolved = true;
+                reject(new TheorumError(`Gemini Live setup timed out after ${SETUP_TIMEOUT_MS}ms`));
+            }
+        }, SETUP_TIMEOUT_MS);
+        ws.onopen = () => {
+            try {
+                const setupMsg = buildGeminiLiveSetupMessage(req);
+                ws.send(JSON.stringify(setupMsg));
+            }
+            catch (err) {
+                clearTimeout(timeout);
+                setupResolved = true;
+                reject(err instanceof Error ? err : new Error(String(err)));
+            }
+        };
+        ws.onerror = () => {
+            clearTimeout(timeout);
+            if (!setupResolved) {
+                setupResolved = true;
+                reject(new TheorumError('Gemini Live WebSocket error during setup'));
+            }
+        };
+        ws.onclose = (evt) => {
+            clearTimeout(timeout);
+            if (!setupResolved) {
+                setupResolved = true;
+                reject(new TheorumError(`Gemini Live WebSocket closed during setup (${evt.code}: ${evt.reason})`));
+            }
+        };
+        const initialMessageHandler = async (evt) => {
+            const rawText = await readMessageData(evt.data);
+            const parsed = parseGeminiLiveMessage(rawText);
+            if (!parsed.ok) {
+                if (parsed.reason === 'empty')
+                    return;
+                clearTimeout(timeout);
+                setupResolved = true;
+                reject(new TheorumError('malformed Gemini Live message during setup'));
+                return;
+            }
+            const errMsg = readGeminiLiveErrorMessage(parsed.value);
+            if (errMsg) {
+                clearTimeout(timeout);
+                setupResolved = true;
+                reject(new TheorumError(errMsg));
+                return;
+            }
+            if (parsed.value.setupComplete) {
+                clearTimeout(timeout);
+                setupResolved = true;
+                ws.removeEventListener('message', initialMessageHandler);
+                resolve();
+            }
+        };
+        ws.addEventListener('message', initialMessageHandler);
+    });
+}
+export function sendInitialPayloads(ws, req) {
+    if (req.history && req.history.length > 0) {
+        const historyMsg = buildGeminiLiveClientContent(req.history);
+        if (historyMsg) {
+            ws.send(JSON.stringify(historyMsg));
+        }
+    }
+    if (req.input && req.input.length > 0) {
+        for (const part of req.input) {
+            const inputMsg = buildGeminiLiveRealtimeInput(part);
+            ws.send(JSON.stringify(inputMsg));
+        }
+    }
+}
+export function createLiveQueue() {
+    const queue = [];
+    let notify = null;
+    let closed = false;
+    return {
+        push(item) {
+            queue.push(item);
+            if (notify) {
+                const fn = notify;
+                notify = null;
+                fn();
+            }
+        },
+        async next() {
+            while (queue.length === 0) {
+                if (closed)
+                    return undefined;
+                await new Promise((resolve) => {
+                    notify = resolve;
+                });
+            }
+            return queue.shift();
+        },
+        close() {
+            closed = true;
+            if (notify) {
+                const fn = notify;
+                notify = null;
+                fn();
+            }
+        },
+        isClosed() {
+            return closed;
+        },
+    };
+}
+/**
+ * Conversational cycle boundary.
+ *
+ * When the server reports `interactionStatus`, that is authoritative: `IDLE`
+ * closes the cycle and `IN_PROGRESS` keeps it open even across `turnComplete`
+ * (background reasoning / async tools may still produce output). Without the
+ * field, `turnComplete` is the boundary as before.
+ */
+export function turnPhaseFromMessage(message, events) {
+    const interrupted = events.some((ev) => ev.type === 'done' && ev.interrupted === true);
+    if (interrupted)
+        return 'abort';
+    const status = readLiveInteractionStatus(message);
+    if (status === 'IDLE')
+        return 'complete';
+    if (status === 'IN_PROGRESS')
+        return 'streaming';
+    const serverContent = message.serverContent;
+    if (serverContent?.turnComplete || serverContent?.turn_complete)
+        return 'complete';
+    return 'streaming';
+}
+/** Attach handlers that keep the socket open across conversational turns. */
+export function attachLiveSessionHandlers(ws, liveQueue) {
+    ws.onmessage = async (evt) => {
+        try {
+            const rawText = await readMessageData(evt.data);
+            const parsed = parseGeminiLiveMessage(rawText);
+            if (!parsed.ok) {
+                if (parsed.reason === 'empty')
+                    return;
+                liveQueue.push({
+                    type: 'error',
+                    error: new TheorumError('malformed Gemini Live message'),
+                });
+                return;
+            }
+            if (parsed.value.setupComplete)
+                return;
+            const errMsg = readGeminiLiveErrorMessage(parsed.value);
+            if (errMsg) {
+                liveQueue.push({ type: 'error', error: new TheorumError(errMsg) });
+                return;
+            }
+            const events = foldGeminiLiveServerMessage(parsed.value);
+            const turnPhase = turnPhaseFromMessage(parsed.value, events);
+            if (events.length > 0 || turnPhase !== 'streaming') {
+                liveQueue.push({ type: 'batch', events, turnPhase });
+            }
+        }
+        catch (err) {
+            liveQueue.push({
+                type: 'error',
+                error: err instanceof Error ? err : new Error(String(err)),
+            });
+        }
+    };
+    ws.onerror = () => {
+        if (!liveQueue.isClosed()) {
+            liveQueue.push({ type: 'error', error: new TheorumError('Gemini Live WebSocket error') });
+        }
+    };
+    ws.onclose = () => {
+        if (!liveQueue.isClosed()) {
+            liveQueue.push({ type: 'closed' });
+            liveQueue.close();
+        }
+    };
+}

package/esm/src/providers/google/urls.d.ts

@@ -0,0 +1,6 @@
+/** Google Interactions API endpoints. */
+declare const INTERACTIONS_URL = "https://generativelanguage.googleapis.com/v1beta/interactions?alt=sse";
+declare const INTERACTIONS_JSON_URL = "https://generativelanguage.googleapis.com/v1beta/interactions";
+/** Google Gemini Live WebSocket endpoint. */
+declare const GEMINI_LIVE_WS_URL = "wss://generativelanguage.googleapis.com/ws/google.ai.generativelanguage.v1beta.GenerativeService.BidiGenerateContent";
+export { GEMINI_LIVE_WS_URL, INTERACTIONS_JSON_URL, INTERACTIONS_URL };

package/esm/src/providers/google/urls.js

@@ -0,0 +1,6 @@
+/** Google Interactions API endpoints. */
+const INTERACTIONS_URL = 'https://generativelanguage.googleapis.com/v1beta/interactions?alt=sse';
+const INTERACTIONS_JSON_URL = 'https://generativelanguage.googleapis.com/v1beta/interactions';
+/** Google Gemini Live WebSocket endpoint. */
+const GEMINI_LIVE_WS_URL = 'wss://generativelanguage.googleapis.com/ws/google.ai.generativelanguage.v1beta.GenerativeService.BidiGenerateContent';
+export { GEMINI_LIVE_WS_URL, INTERACTIONS_JSON_URL, INTERACTIONS_URL };

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

@@ -0,0 +1,30 @@
+/**
+ * Local provider adapter for OpenAI-compatible endpoints (Ollama, llama.cpp,
+ * vLLM, LM Studio, etc.).
+ *
+ * Streams SSE from `/v1/chat/completions`, accumulates tool calls, and yields
+ * normalized `TurnEvent` objects. No external SDK dependency — raw fetch + SSE.
+ *
+ * Wire-format message building delegates to the shared `openai/compat` module.
+ * SSE parsing delegates to the shared `parseSseStream` from `sse.ts`.
+ *
+ * Hosts pass `baseUrl` explicitly. THEORUM does not read `OLLAMA_HOST` or other
+ * environment variables (see docs/contracts/providers.md).
+ *
+ * @module
+ */
+import type { ModelProvider, TurnEvent } from '../../kernel/types.js';
+import { buildChatMessages, wireTools } from '../openrouter/openai/compat.js';
+import type { LocalProviderConfig } from '../types.js';
+/** Default OpenAI-compat base when the host omits `baseUrl` (Ollama's default port). */
+export declare const DEFAULT_LOCAL_BASE_URL = "http://127.0.0.1:11434";
+export type PendingToolCall = {
+    id: string;
+    name: string;
+    args: string;
+};
+export declare function resolveBaseUrl(config?: LocalProviderConfig): string;
+export declare function flushPending(pending: Map<number, PendingToolCall>): TurnEvent[];
+/** Create a `ModelProvider` for a local OpenAI-compatible server (Ollama, llama.cpp, vLLM, LM Studio). */
+declare function createLocalProvider(config?: LocalProviderConfig): ModelProvider;
+export { buildChatMessages as historyToWire, createLocalProvider, wireTools as toolsToWire };

package/esm/src/providers/{local.js → local/local.js}

@@ -5,14 +5,19 @@
  * Streams SSE from `/v1/chat/completions`, accumulates tool calls, and yields
  * normalized `TurnEvent` objects. No external SDK dependency — raw fetch + SSE.
  *
+ * Wire-format message building delegates to the shared `openai/compat` module.
+ * SSE parsing delegates to the shared `parseSseStream` from `sse.ts`.
+ *
  * Hosts pass `baseUrl` explicitly. THEORUM does not read `OLLAMA_HOST` or other
- * environment variables (see src/providers/CONTRACT.md).
+ * environment variables (see docs/contracts/providers.md).
  *
  * @module
  */
-import { isAbortError, toErrorEvent } from '../guardrails/error.js';
-import { turnStopFromOpenRouter } from '../kernel/stop.js';
-import { exposeForTests } from './expose-for-tests.js';
+import { isAbortError, toErrorEvent } from '../../guardrails/error.js';
+import { turnStopFromOpenAiFinishReason } from '../../kernel/stop.js';
+import { buildChatMessages, wireTools } from '../openrouter/openai/compat.js';
+import { parseSseStream } from '../shared/sse.js';
+import { parseToolArgumentsObject } from '../shared/tool-args.js';
 /** Default OpenAI-compat base when the host omits `baseUrl` (Ollama's default port). */
 export const DEFAULT_LOCAL_BASE_URL = 'http://127.0.0.1:11434';
 // ── request mapping ─────────────────────────────────
@@ -22,132 +27,48 @@ function normalizeBaseUrl(baseUrl) {
         end -= 1;
     return baseUrl.slice(0, end);
 }
-function resolveBaseUrl(config) {
+export function resolveBaseUrl(config) {
     return normalizeBaseUrl(config?.baseUrl?.trim() || DEFAULT_LOCAL_BASE_URL);
 }
-function inputToContent(parts) {
-    if (parts.every((p) => p.type === 'text')) {
-        return parts.map((p) => ('text' in p ? p.text : '')).join('\n');
-    }
-    return parts.map((p) => {
-        if (p.type === 'text')
-            return { type: 'text', text: p.text };
-        return {
-            type: 'image_url',
-            image_url: { url: `data:${p.mimeType};base64,${p.data}` },
-        };
-    });
-}
-function historyMessageContent(msg) {
-    if (msg.parts && msg.parts.length > 0) {
-        return inputToContent(msg.parts);
-    }
-    if (msg.content != null)
-        return msg.content;
-    return undefined;
-}
-function historyToWire(req) {
-    const msgs = [];
-    if (req.system)
-        msgs.push({ role: 'system', content: req.system });
-    for (const msg of req.history ?? []) {
-        msgs.push(historyMessageToWire(msg));
-    }
-    if (req.input.length > 0) {
-        msgs.push({ role: 'user', content: inputToContent(req.input) });
-    }
-    return msgs;
-}
-function historyMessageToWire(msg) {
-    if (msg.role === 'tool') {
-        return {
-            role: 'tool',
-            tool_call_id: msg.tool_call_id ?? `call_${msg.name ?? 'tool'}`,
-            name: msg.name,
-            content: msg.content ?? '',
-        };
-    }
-    if (msg.role === 'assistant' && msg.tool_calls && msg.tool_calls.length > 0) {
-        return {
-            role: 'assistant',
-            content: historyMessageContent(msg) ?? undefined,
-            tool_calls: msg.tool_calls.map((tc) => ({
-                id: tc.id,
-                type: 'function',
-                function: { name: tc.function.name, arguments: tc.function.arguments },
-            })),
-        };
-    }
-    return { role: msg.role, content: historyMessageContent(msg) ?? '' };
-}
-function toolsToWire(dynamicTools) {
-    if (!dynamicTools || dynamicTools.length === 0)
-        return undefined;
-    return dynamicTools.map((t) => ({
-        type: 'function',
-        function: {
-            name: t.name,
-            description: t.description ?? '',
-            parameters: t.parameters ?? { type: 'object', properties: {} },
-        },
-    }));
-}
 function buildBody(req) {
     const body = {
         model: req.apiId,
-        messages: historyToWire(req),
+        messages: buildChatMessages(req),
         stream: true,
         stream_options: { include_usage: true },
         temperature: req.temperature,
         max_tokens: req.maxOutputTokens,
     };
-    const tools = toolsToWire(req.dynamicTools);
+    const tools = wireTools(req.wireTools);
     if (tools)
         body.tools = tools;
     return body;
 }
-// ── SSE parsing ─────────────────────────────────────
-async function* parseSse(body) {
-    const reader = body.getReader();
-    const decoder = new TextDecoder();
-    let buffer = '';
-    for (;;) {
-        const { done, value } = await reader.read();
-        if (done)
-            break;
-        buffer += decoder.decode(value, { stream: true });
-        const lines = buffer.split('\n');
-        buffer = lines.pop() ?? '';
-        for (const line of lines) {
-            const trimmed = line.trim();
-            if (!trimmed.startsWith('data: '))
-                continue;
-            const data = trimmed.slice(6);
-            if (data === '[DONE]')
-                return;
-            try {
-                yield JSON.parse(data);
-            }
-            catch {
-                // skip malformed
-            }
-        }
-    }
-}
 // ── stream → TurnEvent ──────────────────────────────
-function flushPending(pending) {
+export function flushPending(pending) {
     const events = [];
     for (const [, tc] of pending) {
-        let parsed = {};
-        try {
-            parsed = JSON.parse(tc.args);
-        }
-        catch {
-            // empty
+        const parsed = parseToolArgumentsObject(tc.args);
+        if (!parsed.ok) {
+            events.push({
+                type: 'tool',
+                tool: {
+                    name: tc.name,
+                    arguments: {},
+                    id: tc.id,
+                    phase: 'error',
+                    failure: {
+                        code: 'malformed_arguments',
+                        message: parsed.error,
+                        details: { raw: parsed.raw },
+                    },
+                },
+            });
+            continue;
         }
         events.push({
             type: 'tool',
-            tool: { name: tc.name, arguments: parsed, id: tc.id },
+            tool: { name: tc.name, arguments: parsed.value, id: tc.id },
         });
     }
     pending.clear();
@@ -174,11 +95,11 @@ async function* streamComplete(baseUrl, req, fetchFn) {
 async function* streamOpenAiBody(body) {
     const pending = new Map();
     let finishReason;
-    for await (const chunk of parseSse(body)) {
-        const usageEvent = tokensFromUsage(chunk.usage);
+    for await (const raw of parseSseStream(body)) {
+        const usageEvent = tokensFromUsage(readOpenAiUsage(raw));
         if (usageEvent)
             yield usageEvent;
-        const choice = chunk.choices?.[0];
+        const choice = firstOpenAiChoice(raw);
         if (!choice)
             continue;
         yield* eventsFromChoiceDelta(choice.delta, pending);
@@ -190,7 +111,37 @@ async function* streamOpenAiBody(body) {
     }
     for (const event of flushPending(pending))
         yield event;
-    yield { type: 'done', stop: turnStopFromOpenRouter(finishReason) };
+    yield { type: 'done', stop: turnStopFromOpenAiFinishReason(finishReason) };
+}
+function readOpenAiUsage(raw) {
+    const usage = raw.usage;
+    if (!usage || typeof usage !== 'object' || Array.isArray(usage))
+        return undefined;
+    const row = usage;
+    return {
+        prompt_tokens: typeof row.prompt_tokens === 'number' ? row.prompt_tokens : undefined,
+        completion_tokens: typeof row.completion_tokens === 'number' ? row.completion_tokens : undefined,
+        total_tokens: typeof row.total_tokens === 'number' ? row.total_tokens : undefined,
+    };
+}
+function firstOpenAiChoice(raw) {
+    if (!Array.isArray(raw.choices) || raw.choices.length === 0)
+        return undefined;
+    const choice = raw.choices[0];
+    if (!choice || typeof choice !== 'object' || Array.isArray(choice))
+        return undefined;
+    const row = choice;
+    const deltaRaw = row.delta;
+    const delta = deltaRaw && typeof deltaRaw === 'object' && !Array.isArray(deltaRaw)
+        ? deltaRaw
+        : undefined;
+    return {
+        index: typeof row.index === 'number' ? row.index : 0,
+        delta,
+        finish_reason: typeof row.finish_reason === 'string' || row.finish_reason === null
+            ? row.finish_reason
+            : undefined,
+    };
 }
 function tokensFromUsage(usage) {
     if (!usage)
@@ -245,15 +196,4 @@ function createLocalProvider(config) {
         },
     };
 }
-export { createLocalProvider };
-exposeForTests('local', {
-    inputToContent,
-    historyMessageContent,
-    historyToWire,
-    toolsToWire,
-    buildBody,
-    parseSse,
-    flushPending,
-    resolveBaseUrl,
-    DEFAULT_LOCAL_BASE_URL,
-});
+export { buildChatMessages as historyToWire, createLocalProvider, wireTools as toolsToWire };