@alexkroman1/aai 1.2.3 → 1.3.0

package/dist/host/runtime-barrel.js

@@ -8,6 +8,7 @@ import { convert } from "html-to-text";
 import vm from "node:vm";
 import pTimeout from "p-timeout";
 import { createStorage, prefixStorage } from "unstorage";
+import { jsonSchema, stepCountIs, streamText, tool } from "ai";
 import { createNanoEvents } from "nanoevents";
 import WsWebSocket, { WebSocketServer } from "ws";
 import fs from "node:fs";
@@ -339,6 +340,103 @@ function resolveAllBuiltins(names, opts) {
 	};
 }
 //#endregion
+//#region sdk/system-prompt.ts
+function getFormattedDate() {
+	return (/* @__PURE__ */ new Date()).toLocaleDateString("en-US", {
+		weekday: "long",
+		year: "numeric",
+		month: "long",
+		day: "numeric"
+	});
+}
+const VOICE_RULES = "\n\nCRITICAL OUTPUT RULES — you MUST follow these for EVERY response:\nYour response will be spoken aloud by a TTS system and displayed as plain text.\n- NEVER use markdown: no **, no *, no _, no #, no `, no [](), no ---\n- NEVER use bullet points (-, *, •) or numbered lists (1., 2.)\n- NEVER use code blocks or inline code\n- NEVER mention tools, search, APIs, or technical failures to the user. If a tool returns no results, just answer naturally without explaining why.\n- Write exactly as you would say it out loud to a friend\n- Use short conversational sentences. To list things, say \"First,\" \"Next,\" \"Finally,\"\n- Keep responses concise — 1 to 3 sentences max";
+/**
+* Build the system prompt sent to the LLM from the agent configuration.
+*
+* Assembles the default system prompt, today's date, agent-specific instructions,
+* and optional sections for tool usage preamble and voice output rules.
+*
+* @param config - The serializable agent configuration (name, systemPrompt, etc.).
+* @param opts.hasTools - When `true`, appends a preamble instructing the LLM to
+*   speak a brief phrase before each tool call to fill silence.
+* @param opts.voice - When `true`, appends strict voice-specific output rules
+*   (no markdown, no bullet points, conversational tone, concise responses).
+* @returns The assembled system prompt string.
+*/
+function buildSystemPrompt(config, opts) {
+	const { hasTools } = opts;
+	const agentInstructions = config.systemPrompt && config.systemPrompt !== DEFAULT_SYSTEM_PROMPT ? `\n\nAgent-Specific Instructions:\n${config.systemPrompt}` : "";
+	const toolPreamble = hasTools ? "\n\nWhen you decide to use a tool, ALWAYS say a brief natural phrase BEFORE the tool call (e.g. \"Let me look that up\" or \"One moment while I check\"). This fills silence while the tool executes. Keep preambles to one short sentence." : "";
+	const guidance = opts.toolGuidance && opts.toolGuidance.length > 0 ? `\n\nBuilt-in Tool Usage:\n${opts.toolGuidance.join("\n")}` : "";
+	return DEFAULT_SYSTEM_PROMPT + `\n\nToday's date is ${getFormattedDate()}.` + agentInstructions + toolPreamble + guidance + (opts.voice ? VOICE_RULES : "");
+}
+//#endregion
+//#region host/session-ctx.ts
+function _buildBaseCtx(opts) {
+	const { agentConfig, log } = opts;
+	const maxHistory = opts.maxHistory ?? 200;
+	const ctx = {
+		...opts,
+		reply: {
+			pendingTools: [],
+			toolCallCount: 0,
+			currentReplyId: null
+		},
+		turnPromise: null,
+		conversationMessages: [],
+		maxHistory,
+		consumeToolCallStep(_name, replyId) {
+			if (replyId === null || replyId !== ctx.reply.currentReplyId) return toolError("Reply was interrupted. Discarding stale tool call.");
+			const maxSteps = agentConfig.maxSteps;
+			ctx.reply.toolCallCount++;
+			if (maxSteps !== void 0 && ctx.reply.toolCallCount > maxSteps) {
+				log.info("maxSteps exceeded, refusing tool call", {
+					toolCallCount: ctx.reply.toolCallCount,
+					maxSteps
+				});
+				return toolError("Maximum tool steps reached. Please respond to the user now.");
+			}
+			return null;
+		},
+		pushMessages(...msgs) {
+			ctx.conversationMessages.push(...msgs);
+			if (maxHistory > 0 && ctx.conversationMessages.length > maxHistory) ctx.conversationMessages.splice(0, ctx.conversationMessages.length - maxHistory);
+		},
+		beginReply(replyId) {
+			ctx.reply = {
+				pendingTools: [],
+				toolCallCount: 0,
+				currentReplyId: replyId
+			};
+			ctx.turnPromise = null;
+		},
+		cancelReply() {
+			ctx.reply = {
+				pendingTools: [],
+				toolCallCount: 0,
+				currentReplyId: null
+			};
+		},
+		chainTurn(p) {
+			ctx.turnPromise = (ctx.turnPromise ?? Promise.resolve()).then(() => p);
+		}
+	};
+	return ctx;
+}
+function buildCtx(opts) {
+	const base = _buildBaseCtx(opts);
+	base.s2s = null;
+	return base;
+}
+//#endregion
+//#region host/pipeline-session-ctx.ts
+function buildPipelineCtx(opts) {
+	const base = _buildBaseCtx(opts);
+	base.stt = null;
+	base.tts = null;
+	return base;
+}
+//#endregion
 //#region host/runtime-config.ts
 /**
 * Runtime dependencies injected into the session pipeline.
@@ -385,35 +483,371 @@ const DEFAULT_S2S_CONFIG = {
 	outputSampleRate: DEFAULT_TTS_SAMPLE_RATE
 };
 //#endregion
-//#region sdk/system-prompt.ts
-function getFormattedDate() {
-	return (/* @__PURE__ */ new Date()).toLocaleDateString("en-US", {
-		weekday: "long",
-		year: "numeric",
-		month: "long",
-		day: "numeric"
-	});
-}
-const VOICE_RULES = "\n\nCRITICAL OUTPUT RULES — you MUST follow these for EVERY response:\nYour response will be spoken aloud by a TTS system and displayed as plain text.\n- NEVER use markdown: no **, no *, no _, no #, no `, no [](), no ---\n- NEVER use bullet points (-, *, •) or numbered lists (1., 2.)\n- NEVER use code blocks or inline code\n- NEVER mention tools, search, APIs, or technical failures to the user. If a tool returns no results, just answer naturally without explaining why.\n- Write exactly as you would say it out loud to a friend\n- Use short conversational sentences. To list things, say \"First,\" \"Next,\" \"Finally,\"\n- Keep responses concise — 1 to 3 sentences max";
+//#region host/to-vercel-tools.ts
 /**
-* Build the system prompt sent to the LLM from the agent configuration.
+* Converts agent {@link ToolSchema}[] to Vercel AI SDK tools with `execute`
+* delegation to the agent's {@link ExecuteTool} function.
 *
-* Assembles the default system prompt, today's date, agent-specific instructions,
-* and optional sections for tool usage preamble and voice output rules.
+* The pipeline orchestrator passes the output to `streamText({ tools })`.
+* Each produced tool's `execute` closure calls
+* `ctx.executeTool(name, args, sessionId, messages(), { signal, toolCallId })`,
+* so the existing agent tool infrastructure (argument validation, KV, hooks,
+* timeout) remains the single source of truth for tool behavior.
 *
-* @param config - The serializable agent configuration (name, systemPrompt, etc.).
-* @param opts.hasTools - When `true`, appends a preamble instructing the LLM to
-*   speak a brief phrase before each tool call to fill silence.
-* @param opts.voice - When `true`, appends strict voice-specific output rules
-*   (no markdown, no bullet points, conversational tone, concise responses).
-* @returns The assembled system prompt string.
+* Per-call `options.abortSignal` (forwarded by `streamText` when the
+* outer turn is aborted, e.g. barge-in) takes precedence over the
+* bag-level `ctx.signal` so individual invocations respect streamText
+* aborts.
 */
-function buildSystemPrompt(config, opts) {
-	const { hasTools } = opts;
-	const agentInstructions = config.systemPrompt && config.systemPrompt !== DEFAULT_SYSTEM_PROMPT ? `\n\nAgent-Specific Instructions:\n${config.systemPrompt}` : "";
-	const toolPreamble = hasTools ? "\n\nWhen you decide to use a tool, ALWAYS say a brief natural phrase BEFORE the tool call (e.g. \"Let me look that up\" or \"One moment while I check\"). This fills silence while the tool executes. Keep preambles to one short sentence." : "";
-	const guidance = opts.toolGuidance && opts.toolGuidance.length > 0 ? `\n\nBuilt-in Tool Usage:\n${opts.toolGuidance.join("\n")}` : "";
-	return DEFAULT_SYSTEM_PROMPT + `\n\nToday's date is ${getFormattedDate()}.` + agentInstructions + toolPreamble + guidance + (opts.voice ? VOICE_RULES : "");
+/**
+* Convert an array of {@link ToolSchema} to a Vercel AI SDK `ToolSet`
+* (record keyed by tool name).
+*
+* Uses the v6 `tool()` helper with `inputSchema: jsonSchema(...)` wrapping
+* the agent's JSON Schema `parameters`. Execution is delegated to
+* `ctx.executeTool` so validation, KV, timeouts, and hooks keep working.
+*/
+function toVercelTools(schemas, ctx) {
+	const out = {};
+	for (const schema of schemas) out[schema.name] = tool({
+		description: schema.description,
+		inputSchema: jsonSchema(schema.parameters),
+		execute: async (args, options) => {
+			const input = args ?? {};
+			const signal = options.abortSignal ?? ctx.signal;
+			const opts = {};
+			if (signal !== void 0) opts.signal = signal;
+			if (options.toolCallId !== void 0) opts.toolCallId = options.toolCallId;
+			return ctx.executeTool(schema.name, input, ctx.sessionId, ctx.messages(), opts);
+		}
+	});
+	return out;
+}
+//#endregion
+//#region host/pipeline-session.ts
+function toModelMessage(m) {
+	if (m.role === "user") return {
+		role: "user",
+		content: m.content
+	};
+	if (m.role === "assistant") return {
+		role: "assistant",
+		content: m.content
+	};
+	return {
+		role: "assistant",
+		content: m.content
+	};
+}
+function emitError(client, code, message) {
+	client.event({
+		type: "error",
+		code,
+		message
+	});
+}
+function handleStreamPart(part, deps) {
+	switch (part.type) {
+		case "text-delta": {
+			const delta = part.text ?? "";
+			if (delta.length === 0) return;
+			deps.onTextDelta(delta);
+			deps.tts?.sendText(delta);
+			deps.client.event({
+				type: "agent_transcript",
+				text: delta
+			});
+			return;
+		}
+		case "tool-call": {
+			const input = part.input ?? {};
+			deps.client.event({
+				type: "tool_call",
+				toolCallId: part.toolCallId ?? "",
+				toolName: part.toolName ?? "",
+				args: input
+			});
+			return;
+		}
+		case "tool-result": {
+			const output = part.output;
+			const resultString = typeof output === "string" ? output : JSON.stringify(output);
+			deps.client.event({
+				type: "tool_call_done",
+				toolCallId: part.toolCallId ?? "",
+				result: resultString
+			});
+			return;
+		}
+		case "error": {
+			const msg = errorMessage(part.error);
+			deps.log.error("LLM stream error", {
+				message: msg,
+				sessionId: deps.sessionId
+			});
+			emitError(deps.client, "llm", msg);
+			return;
+		}
+		default: return;
+	}
+}
+/** Create a pluggable-provider voice session. */
+function createPipelineSession(opts) {
+	const log = opts.logger ?? consoleLogger;
+	const sampleRate = opts.sampleRate ?? 16e3;
+	const { client, agentConfig, toolSchemas, executeTool } = opts;
+	const systemPrompt = buildSystemPrompt(agentConfig, {
+		hasTools: toolSchemas.length > 0 || (agentConfig.builtinTools?.length ?? 0) > 0,
+		voice: true,
+		toolGuidance: opts.toolGuidance
+	});
+	const ctx = buildPipelineCtx({
+		id: opts.id,
+		agent: opts.agent,
+		client,
+		agentConfig,
+		executeTool,
+		log,
+		maxHistory: opts.maxHistory
+	});
+	const sessionAbort = new AbortController();
+	let audioReady = false;
+	let turnController = null;
+	let nextReplyId = 0;
+	const sttSubs = [];
+	const ttsSubs = [];
+	function onSttPartial(_text) {
+		if (turnController === null) return;
+		log.info("Pipeline barge-in", { sessionId: opts.id });
+		turnController.abort();
+		turnController = null;
+		ctx.tts?.cancel();
+		ctx.cancelReply();
+		client.event({ type: "cancelled" });
+	}
+	function onSttFinal(text) {
+		const trimmed = text.trim();
+		if (trimmed.length === 0) return;
+		client.event({
+			type: "user_transcript",
+			text
+		});
+		const turn = runTurn(trimmed).catch((err) => {
+			log.error("Pipeline turn crashed", {
+				error: errorMessage(err),
+				sessionId: opts.id
+			});
+		});
+		ctx.chainTurn(turn);
+	}
+	function onSttError(err) {
+		log.error("STT error", {
+			code: err.code,
+			message: err.message,
+			sessionId: opts.id
+		});
+		emitError(client, "stt", err.message);
+	}
+	function onTtsError(err) {
+		log.error("TTS error", {
+			code: err.code,
+			message: err.message,
+			sessionId: opts.id
+		});
+		emitError(client, "tts", err.message);
+	}
+	async function consumeLlmStream(ctl, messages, tools, onDelta) {
+		const deps = {
+			client,
+			tts: ctx.tts,
+			log,
+			sessionId: opts.id,
+			onTextDelta: onDelta
+		};
+		try {
+			const maxSteps = agentConfig.maxSteps ?? 5;
+			const result = streamText({
+				model: opts.llm,
+				system: systemPrompt,
+				messages,
+				tools,
+				stopWhen: stepCountIs(maxSteps),
+				abortSignal: ctl.signal
+			});
+			for await (const part of result.fullStream) {
+				if (ctl.signal.aborted) break;
+				handleStreamPart(part, deps);
+			}
+		} catch (err) {
+			if (!ctl.signal.aborted) {
+				const msg = errorMessage(err);
+				log.error("LLM streamText failed", {
+					error: msg,
+					sessionId: opts.id
+				});
+				emitError(client, "llm", msg);
+			}
+		}
+	}
+	function flushTtsAndWait() {
+		const tts = ctx.tts;
+		if (!tts) return Promise.resolve();
+		return new Promise((resolve) => {
+			const off = tts.on("done", () => {
+				off();
+				resolve();
+			});
+			tts.flush();
+		});
+	}
+	async function runTurn(userText) {
+		const replyId = `pipeline-${++nextReplyId}`;
+		ctx.beginReply(replyId);
+		ctx.pushMessages({
+			role: "user",
+			content: userText
+		});
+		const ctl = new AbortController();
+		turnController = ctl;
+		const tools = toVercelTools(toolSchemas, {
+			executeTool,
+			sessionId: opts.id,
+			messages: () => ctx.conversationMessages,
+			signal: ctl.signal
+		});
+		const messages = ctx.conversationMessages.map(toModelMessage);
+		let accumulated = "";
+		await consumeLlmStream(ctl, messages, tools, (delta) => {
+			accumulated += delta;
+		});
+		if (ctl.signal.aborted) {
+			if (turnController === ctl) turnController = null;
+			return;
+		}
+		await flushTtsAndWait();
+		if (ctl.signal.aborted) {
+			if (turnController === ctl) turnController = null;
+			return;
+		}
+		if (accumulated.length > 0) ctx.pushMessages({
+			role: "assistant",
+			content: accumulated
+		});
+		client.playAudioDone();
+		client.event({ type: "reply_done" });
+		if (turnController === ctl) turnController = null;
+	}
+	async function openProviders() {
+		const [sttResult, ttsResult] = await Promise.allSettled([opts.stt.open({
+			sampleRate,
+			apiKey: opts.sttApiKey,
+			sttPrompt: agentConfig.sttPrompt,
+			signal: sessionAbort.signal
+		}), opts.tts.open({
+			sampleRate,
+			apiKey: opts.ttsApiKey,
+			signal: sessionAbort.signal
+		})]);
+		if (sttResult.status === "rejected") {
+			const msg = errorMessage(sttResult.reason);
+			log.error("STT open failed", {
+				error: msg,
+				sessionId: opts.id
+			});
+			emitError(client, "stt", msg);
+		}
+		if (ttsResult.status === "rejected") {
+			const msg = errorMessage(ttsResult.reason);
+			log.error("TTS open failed", {
+				error: msg,
+				sessionId: opts.id
+			});
+			emitError(client, "tts", msg);
+		}
+		const aborted = sessionAbort.signal.aborted;
+		const sttFailed = sttResult.status === "rejected";
+		const ttsFailed = ttsResult.status === "rejected";
+		const teardown = aborted || sttFailed || ttsFailed;
+		if (sttResult.status === "fulfilled") {
+			const sttSession = sttResult.value;
+			if (teardown) await sttSession.close().catch(() => void 0);
+			else {
+				ctx.stt = sttSession;
+				sttSubs.push(sttSession.on("partial", onSttPartial));
+				sttSubs.push(sttSession.on("final", onSttFinal));
+				sttSubs.push(sttSession.on("error", onSttError));
+			}
+		}
+		if (ttsResult.status === "fulfilled") {
+			const ttsSession = ttsResult.value;
+			if (teardown) await ttsSession.close().catch(() => void 0);
+			else {
+				ctx.tts = ttsSession;
+				ttsSubs.push(ttsSession.on("audio", (pcm) => {
+					client.playAudioChunk(new Uint8Array(pcm.buffer, pcm.byteOffset, pcm.byteLength));
+				}));
+				ttsSubs.push(ttsSession.on("error", onTtsError));
+			}
+		}
+	}
+	return {
+		async start() {
+			await openProviders();
+		},
+		async stop() {
+			if (sessionAbort.signal.aborted) return;
+			sessionAbort.abort();
+			turnController?.abort();
+			for (const off of sttSubs) off();
+			for (const off of ttsSubs) off();
+			sttSubs.length = 0;
+			ttsSubs.length = 0;
+			if (ctx.turnPromise !== null) await ctx.turnPromise;
+			await ctx.stt?.close().catch(() => {});
+			await ctx.tts?.close().catch(() => {});
+		},
+		onAudio(data) {
+			if (!audioReady) return;
+			const offset = data.byteOffset;
+			const length = data.byteLength;
+			let pcm;
+			if (offset % 2 === 0 && length % 2 === 0) pcm = new Int16Array(data.buffer, offset, length / 2);
+			else {
+				const copy = new Uint8Array(length - length % 2);
+				copy.set(data.subarray(0, copy.byteLength));
+				pcm = new Int16Array(copy.buffer);
+			}
+			ctx.stt?.sendAudio(pcm);
+		},
+		onAudioReady() {
+			audioReady = true;
+		},
+		onCancel() {
+			turnController?.abort();
+			turnController = null;
+			ctx.tts?.cancel();
+			ctx.cancelReply();
+			client.event({ type: "cancelled" });
+		},
+		onReset() {
+			turnController?.abort();
+			turnController = null;
+			ctx.tts?.cancel();
+			ctx.cancelReply();
+			ctx.conversationMessages = [];
+			ctx.turnPromise = null;
+			client.event({ type: "reset" });
+		},
+		onHistory(incoming) {
+			ctx.pushMessages(...incoming.map((m) => ({
+				role: m.role,
+				content: m.content
+			})));
+		},
+		waitForTurn() {
+			return ctx.turnPromise ?? Promise.resolve();
+		}
+	};
 }
 //#endregion
 //#region host/s2s.ts
@@ -544,6 +978,10 @@ function connectS2s(opts) {
 				}
 				ws.send(`{"type":"input.audio","audio":"${uint8ToBase64(audio)}"}`);
 			},
+			sendAudioRaw(jsonFrame) {
+				if (ws.readyState !== 1) return;
+				ws.send(jsonFrame);
+			},
 			sendToolResult(callId, result) {
 				const msg = {
 					type: "tool.result",
@@ -639,60 +1077,6 @@ function connectS2s(opts) {
 	});
 }
 //#endregion
-//#region host/session-ctx.ts
-function buildCtx(opts) {
-	const { agentConfig, log } = opts;
-	const maxHistory = opts.maxHistory ?? 200;
-	const ctx = {
-		...opts,
-		s2s: null,
-		reply: {
-			pendingTools: [],
-			toolCallCount: 0,
-			currentReplyId: null
-		},
-		turnPromise: null,
-		conversationMessages: [],
-		maxHistory,
-		consumeToolCallStep(_name, replyId) {
-			if (replyId === null || replyId !== ctx.reply.currentReplyId) return toolError("Reply was interrupted. Discarding stale tool call.");
-			const maxSteps = agentConfig.maxSteps;
-			ctx.reply.toolCallCount++;
-			if (maxSteps !== void 0 && ctx.reply.toolCallCount > maxSteps) {
-				log.info("maxSteps exceeded, refusing tool call", {
-					toolCallCount: ctx.reply.toolCallCount,
-					maxSteps
-				});
-				return toolError("Maximum tool steps reached. Please respond to the user now.");
-			}
-			return null;
-		},
-		pushMessages(...msgs) {
-			ctx.conversationMessages.push(...msgs);
-			if (maxHistory > 0 && ctx.conversationMessages.length > maxHistory) ctx.conversationMessages.splice(0, ctx.conversationMessages.length - maxHistory);
-		},
-		beginReply(replyId) {
-			ctx.reply = {
-				pendingTools: [],
-				toolCallCount: 0,
-				currentReplyId: replyId
-			};
-			ctx.turnPromise = null;
-		},
-		cancelReply() {
-			ctx.reply = {
-				pendingTools: [],
-				toolCallCount: 0,
-				currentReplyId: null
-			};
-		},
-		chainTurn(p) {
-			ctx.turnPromise = (ctx.turnPromise ?? Promise.resolve()).then(() => p);
-		}
-	};
-	return ctx;
-}
-//#endregion
 //#region host/session.ts
 /** @internal Not part of the public API. Exposed for testing only. */
 const _internals = { connectS2s };
@@ -1288,6 +1672,17 @@ function createLocalKv() {
 	return createUnstorageKv({ storage: createStorage() });
 }
 /**
+* Resolve an API key host-side for pipeline providers.
+*
+* Checks the agent's declared env first, then the host process env as a
+* fallback. Returns `""` when absent — pipeline providers surface a clear
+* `MissingCredentialsError` via their `open()` that the orchestrator
+* converts to a `session.error` wire event.
+*/
+function resolveApiKey(envVar, env) {
+	return env[envVar] ?? process.env[envVar] ?? "";
+}
+/**
 * Create an agent runtime — the execution engine for a voice agent.
 *
 * Merges built-in and custom tool definitions, builds tool schemas for the
@@ -1301,6 +1696,9 @@ function createLocalKv() {
 */
 function createRuntime(opts) {
 	const { agent, env, kv = createLocalKv(), createWebSocket, logger = consoleLogger, s2sConfig = DEFAULT_S2S_CONFIG, sessionStartTimeoutMs, shutdownTimeoutMs = DEFAULT_SHUTDOWN_TIMEOUT_MS } = opts;
+	const providerCount = (opts.stt != null ? 1 : 0) + (opts.llm != null ? 1 : 0) + (opts.tts != null ? 1 : 0);
+	if (providerCount !== 0 && providerCount !== 3) throw new Error("stt, llm, and tts must be set together");
+	const mode = providerCount === 3 ? "pipeline" : "s2s";
 	const agentConfig = toAgentConfig(agent);
 	const sessions = /* @__PURE__ */ new Map();
 	const sinkMap = /* @__PURE__ */ new Map();
@@ -1365,6 +1763,26 @@ function createRuntime(opts) {
 	}
 	function createSession(sessionOpts) {
 		sinkMap.set(sessionOpts.id, sessionOpts.client);
+		if (mode === "pipeline") {
+			const stt = opts.stt;
+			const llm = opts.llm;
+			const tts = opts.tts;
+			return createPipelineSession({
+				id: sessionOpts.id,
+				agent: sessionOpts.agent,
+				client: sessionOpts.client,
+				agentConfig,
+				toolSchemas,
+				toolGuidance,
+				executeTool,
+				stt,
+				llm,
+				tts,
+				sttApiKey: resolveApiKey("ASSEMBLYAI_API_KEY", env),
+				ttsApiKey: resolveApiKey("CARTESIA_API_KEY", env),
+				logger
+			});
+		}
 		const apiKey = env.ASSEMBLYAI_API_KEY ?? "";
 		return createS2sSession({
 			id: sessionOpts.id,
@@ -1565,4 +1983,4 @@ function createServer(options) {
 	};
 }
 //#endregion
-export { DEFAULT_S2S_CONFIG, _internals, buildCtx, consoleLogger, createRuntime, createS2sSession, createServer, createUnstorageKv, executeInIsolate, executeToolCall, jsonLogger, resolveAllBuiltins, wireSessionSocket };
+export { DEFAULT_S2S_CONFIG, _buildBaseCtx, _internals, buildCtx, consoleLogger, createRuntime, createS2sSession, createServer, createUnstorageKv, executeInIsolate, executeToolCall, jsonLogger, resolveAllBuiltins, wireSessionSocket };

package/dist/host/runtime.d.ts

@@ -9,6 +9,7 @@ import { type ToolSchema } from "../sdk/_internal-types.ts";
 import type { Kv } from "../sdk/kv.ts";
 import type { ClientSink } from "../sdk/protocol.ts";
 import { type ReadyConfig } from "../sdk/protocol.ts";
+import type { LlmProvider, SttProvider, TtsProvider } from "../sdk/providers.ts";
 import type { AgentDef } from "../sdk/types.ts";
 import type { Logger, S2SConfig } from "./runtime-config.ts";
 import type { CreateS2sWebSocket } from "./s2s.ts";
@@ -89,6 +90,22 @@ export type RuntimeOptions = {
      * their own fetch wrapper.
      */
     fetch?: typeof globalThis.fetch | undefined;
+    /**
+     * Pluggable STT provider. Must be set together with `llm` and `tts` to
+     * route sessions through the pipeline path; leave all three unset for
+     * the default AssemblyAI Streaming Speech-to-Speech (S2S) path.
+     */
+    stt?: SttProvider | undefined;
+    /**
+     * Pluggable LLM provider (Vercel AI SDK `LanguageModel`). Must be set
+     * together with `stt` and `tts` to route sessions through the pipeline path.
+     */
+    llm?: LlmProvider | undefined;
+    /**
+     * Pluggable TTS provider. Must be set together with `stt` and `llm` to
+     * route sessions through the pipeline path.
+     */
+    tts?: TtsProvider | undefined;
 };
 /**
  * The agent runtime returned by {@link createRuntime}.

package/dist/host/s2s.d.ts

@@ -62,6 +62,11 @@ export type S2sEvents = {
 export type S2sHandle = {
     on<K extends keyof S2sEvents>(event: K, cb: S2sEvents[K]): Unsubscribe;
     sendAudio(audio: Uint8Array): void;
+    /**
+     * Send a pre-encoded audio wire frame. For perf-critical callers (load tests)
+     * that batch-encode up front. Skips logging; caller owns wire format.
+     */
+    sendAudioRaw(jsonFrame: string): void;
     sendToolResult(callId: string, result: string): void;
     updateSession(config: S2sSessionConfig): void;
     resumeSession(sessionId: string): void;