@alexkroman1/aai 1.7.1 → 1.8.0

package/dist/host/runtime-barrel.js

@@ -1,13 +1,14 @@
-import { r as DEFAULT_SYSTEM_PROMPT } from "../types-KUgezM6u.js";
-import { _ as TOOL_EXECUTION_TIMEOUT_MS, a as DEFAULT_SHUTDOWN_TIMEOUT_MS, c as FETCH_TIMEOUT_MS, d as MAX_PAGE_CHARS, g as RUN_CODE_TIMEOUT_MS, h as PIPELINE_FLUSH_TIMEOUT_MS, l as MAX_HTML_BYTES, m as MAX_WS_PAYLOAD_BYTES, o as DEFAULT_STT_SAMPLE_RATE, p as MAX_VALUE_SIZE, s as DEFAULT_TTS_SAMPLE_RATE, t as AGENT_CSP } from "../constants-C2nirZUI.js";
-import { i as toolError, n as errorDetail, r as errorMessage, t as parseWsUpgradeParams } from "../ws-upgrade-BeOQ7fXL.js";
+import { r as DEFAULT_SYSTEM_PROMPT } from "../types-DOWVZhb9.js";
+import { _ as TOOL_EXECUTION_TIMEOUT_MS, a as DEFAULT_SHUTDOWN_TIMEOUT_MS, c as FETCH_TIMEOUT_MS, d as MAX_PAGE_CHARS, g as RUN_CODE_TIMEOUT_MS, h as PIPELINE_FLUSH_TIMEOUT_MS, l as MAX_HTML_BYTES, m as MAX_WS_PAYLOAD_BYTES, o as DEFAULT_STT_SAMPLE_RATE, p as MAX_VALUE_SIZE, s as DEFAULT_TTS_SAMPLE_RATE, t as AGENT_CSP } from "../constants-y68COEGj.js";
+import { i as toolError, n as errorDetail, r as errorMessage, t as parseWsUpgradeParams } from "../ws-upgrade-CG8-by1n.js";
 import { ClientMessageSchema, VectorRequestSchema, buildReadyConfig, lenientParse } from "../sdk/protocol.js";
-import { a as toAgentConfig, c as makeSttError, i as agentToolsToSchemas, l as makeTtsError, n as EMPTY_PARAMS, s as assertProviderTriple } from "../_internal-types-CrnTi9Ew.js";
+import { a as toAgentConfig, c as makeSttError, i as agentToolsToSchemas, l as makeTtsError, n as EMPTY_PARAMS, s as assertProviderTriple } from "../_internal-types-CfOAbK6V.js";
 import { a as MISTRAL_KIND, d as ANTHROPIC_KIND, l as GOOGLE_KIND, r as OPENAI_KIND, s as GROQ_KIND } from "../xai-BDI61Y2M.js";
 import { a as DEEPGRAM_KIND, r as ELEVENLABS_KIND, s as ASSEMBLYAI_KIND, t as SONIOX_KIND } from "../soniox-BQdL0mB5.js";
 import { a as CARTESIA_KIND, n as RIME_KIND } from "../rime-58p9mDR8.js";
 import { a as MEMORY_KV_KIND, r as REDIS_KV_KIND } from "../s3-BtCMvCod.js";
 import { r as IN_MEMORY_VECTOR_KIND, t as PINECONE_VECTOR_KIND } from "../pinecone-CeJ69aRs.js";
+import "../openai-realtime-cjPAHMMx.js";
 import { createRequire } from "node:module";
 import { z } from "zod";
 import { convert } from "html-to-text";
@@ -35,20 +36,12 @@ import path from "node:path";
 import escapeHtml from "escape-html";
 import { lookup } from "mime-types";
 //#region host/_run-code.ts
-/**
-* run_code built-in tool — executes user JavaScript in a fresh `node:vm`
-* context with no network, filesystem, or process access.
-*/
 const SKIPPED_CLASS_KEYS = new Set([
 	"constructor",
 	"prototype",
 	"length",
 	"name"
 ]);
-/**
-* Copy static members from a class constructor to a wrapper function,
-* skipping built-in keys that must not be forwarded.
-*/
 function copyStaticMembers(src, dst) {
 	for (const key of Object.getOwnPropertyNames(src)) {
 		if (SKIPPED_CLASS_KEYS.has(key)) continue;
@@ -59,16 +52,10 @@ function copyStaticMembers(src, dst) {
 	}
 }
 /**
-* Neuter the `.constructor` chain on a host function or class constructor.
-*
-* For plain functions: wraps the function so calling `.constructor` or
-* `.constructor.constructor` no longer exposes the host `Function`.
-*
-* For class constructors: additionally copies static methods and neutralizes
-* `prototype.constructor` so instances created via `new` also cannot escape.
-*
-* This prevents sandbox code from reaching the host `Function` constructor
-* via patterns like `fn.constructor.constructor('return process')()`.
+* Prevents sandbox code from reaching the host `Function` constructor via
+* `fn.constructor.constructor('return process')()`. For class constructors
+* we also copy static members and neuter `prototype.constructor` so
+* instances created via `new` cannot escape either.
 */
 function neutralizeConstructor(fn) {
 	const hasPrototype = typeof fn.prototype === "object" && fn.prototype !== null;
@@ -92,19 +79,6 @@ function neutralizeConstructor(fn) {
 	return Wrapper;
 }
 const runCodeParams = z.object({ code: z.string().describe("JavaScript code to execute. Use console.log() for output.") });
-/**
-* Execute JavaScript code inside a fresh `node:vm` context.
-*
-* Each invocation creates a disposable VM context with:
-* - No filesystem access (`node:fs` and other built-ins unavailable)
-* - No network access (`fetch`, `http` unavailable)
-* - No child process spawning
-* - No environment variable access (`process` unavailable)
-* - Execution timeout (default 5 s)
-*
-* The context is discarded after execution, so no state leaks between
-* invocations or across sessions.
-*/
 function createRunCode() {
 	return {
 		guidance: "You MUST use the run_code tool for ANY question involving math, counting, calculations, data processing, or code. NEVER do mental math or recite code verbally. run_code executes JavaScript (not Python). Always write JavaScript.",
@@ -115,14 +89,6 @@ function createRunCode() {
 		}
 	};
 }
-/**
-* Execute user code in a fresh `node:vm` context.
-*
-* @remarks
-* The VM context only exposes standard ECMAScript globals and a console
-* object that captures output. Node.js APIs (`process`, `require`,
-* `import()`) are not available inside the sandbox.
-*/
 async function executeInIsolate(code) {
 	const output = [];
 	const capture = (...args) => output.push(args.map(String).join(" "));
@@ -258,12 +224,11 @@ function createVisitWebpage(fetchFn = globalThis.fetch) {
 				error: `Failed to fetch: ${resp.status} ${resp.statusText}`,
 				url
 			};
-			const htmlContent = await resp.text();
-			const text = htmlToText(htmlContent.length > 2e5 ? htmlContent.slice(0, MAX_HTML_BYTES) : htmlContent);
+			const text = htmlToText((await resp.text()).slice(0, MAX_HTML_BYTES));
 			const truncated = text.length > MAX_PAGE_CHARS;
 			return {
 				url,
-				content: truncated ? text.slice(0, MAX_PAGE_CHARS) : text,
+				content: text.slice(0, MAX_PAGE_CHARS),
 				...truncated ? {
 					truncated: true,
 					totalChars: text.length
@@ -323,7 +288,6 @@ function createFetchJson(fetchFn = globalThis.fetch) {
 		}
 	};
 }
-/** Resolve a builtin name to an array of [toolName, ToolDef] pairs. */
 function resolveBuiltin(name, opts) {
 	switch (name) {
 		case "web_search": return [["web_search", createWebSearch(opts?.fetch)]];
@@ -349,8 +313,7 @@ function resolveAllBuiltins(names, opts) {
 			description: def.description,
 			parameters: z.toJSONSchema(def.parameters ?? EMPTY_PARAMS)
 		});
-		const g = def.guidance;
-		if (g) guidance.push(g);
+		if (def.guidance) guidance.push(def.guidance);
 	}
 	return {
 		defs,
@@ -360,16 +323,7 @@ function resolveAllBuiltins(names, opts) {
 }
 //#endregion
 //#region host/memory-vector.ts
-/**
-* In-memory Vector implementation.
-*
-* INTENTIONALLY BAD QUALITY. Pseudo-embedding hashes the text into a
-* 64-dim Float32Array of values in [-1, ~0.99], then L2-normalizes
-* the result. Because both stored and probe vectors are unit-length,
-* cosine similarity reduces to a plain dot product — that's what
-* `cosine()` computes. Used only for `aai dev` and tests — the goal
-* is proving tool wiring, not retrieval ranking.
-*/
+const DIM = 64;
 const stores = /* @__PURE__ */ new Map();
 function getStore(ns) {
 	let store = stores.get(ns);
@@ -379,13 +333,14 @@ function getStore(ns) {
 	}
 	return store;
 }
-const DIM = 64;
 function pseudoEmbed(text) {
 	const out = new Float32Array(DIM);
 	const h1 = createHash("sha256").update(text).digest();
 	const h2 = createHash("sha256").update(h1).digest();
-	for (let i = 0; i < 32; i++) out[i] = (h1[i] - 128) / 128;
-	for (let i = 0; i < 32; i++) out[i + 32] = (h2[i] - 128) / 128;
+	for (let i = 0; i < 32; i++) {
+		out[i] = (h1[i] - 128) / 128;
+		out[i + 32] = (h2[i] - 128) / 128;
+	}
 	let norm = 0;
 	for (let i = 0; i < DIM; i++) norm += out[i] * out[i];
 	norm = Math.sqrt(norm) || 1;
@@ -421,12 +376,13 @@ function createMemoryVector(opts) {
 			const scored = [];
 			for (const [id, rec] of getStore(ns)) {
 				if (filter && !matches(rec.metadata, filter)) continue;
-				scored.push({
+				const match = {
 					id,
 					score: cosine(probe, rec.vec),
-					text: rec.text,
-					...rec.metadata !== void 0 ? { metadata: rec.metadata } : {}
-				});
+					text: rec.text
+				};
+				if (rec.metadata !== void 0) match.metadata = rec.metadata;
+				scored.push(match);
 			}
 			scored.sort((a, b) => b.score - a.score);
 			return scored.slice(0, topK);
@@ -440,24 +396,9 @@ function createMemoryVector(opts) {
 }
 //#endregion
 //#region host/providers/stt/assemblyai.ts
-/**
-* AssemblyAI Universal-Streaming STT opener (host-only).
-*
-* The user-facing descriptor factory (`assemblyAI(...)`) lives in
-* `sdk/providers/stt/assemblyai.ts`. This module is the host-side
-* counterpart: it takes the descriptor options + an API key and
-* returns an {@link SttOpener} that the pipeline session drives.
-*
-* Default model: `"u3pro-rt"` (Universal-3 Pro Real-Time). The adapter
-* maps that to the SDK's `"u3-rt-pro"` `speechModel` value; any other
-* string is forwarded verbatim.
-*/
-/** Translate the descriptor's model alias to the SDK's `speechModel` value. */
 function resolveSpeechModel(model) {
-	if (model === "u3pro-rt") return "u3-rt-pro";
-	return model;
+	return model === "u3pro-rt" ? "u3-rt-pro" : model;
 }
-/** Build an {@link SttOpener} from resolved AssemblyAI descriptor options. */
 function openAssemblyAI(opts = {}) {
 	return {
 		name: "assemblyai",
@@ -476,17 +417,16 @@ function openAssemblyAI(opts = {}) {
 			transcriber.on("turn", (event) => {
 				if (closed) return;
 				const text = event.transcript ?? "";
-				if (event.end_of_turn) {
-					if (text.length > 0) emitter.emit("final", text);
-				} else if (text.length > 0) emitter.emit("partial", text);
+				if (text.length === 0) return;
+				emitter.emit(event.end_of_turn ? "final" : "partial", text);
 			});
 			transcriber.on("error", (err) => {
 				if (closed) return;
 				emitter.emit("error", makeSttError("stt_stream_error", err?.message ?? String(err)));
 			});
 			transcriber.on("close", (code) => {
-				if (closed) return;
-				if (code !== 1e3) emitter.emit("error", makeSttError("stt_stream_error", `socket closed ${code}`));
+				if (closed || code === 1e3) return;
+				emitter.emit("error", makeSttError("stt_stream_error", `socket closed ${code}`));
 			});
 			try {
 				await transcriber.connect();
@@ -505,8 +445,7 @@ function openAssemblyAI(opts = {}) {
 			return {
 				sendAudio(pcm) {
 					if (closed) return;
-					const copy = new Uint8Array(pcm.byteLength);
-					copy.set(new Uint8Array(pcm.buffer, pcm.byteOffset, pcm.byteLength));
+					const copy = new Uint8Array(pcm.buffer.slice(pcm.byteOffset, pcm.byteOffset + pcm.byteLength));
 					transcriber.sendAudio(copy.buffer);
 				},
 				on(event, fn) {
@@ -523,33 +462,18 @@ function openAssemblyAI(opts = {}) {
 /**
 * Deepgram Nova streaming STT opener (host-only).
 *
-* The user-facing descriptor factory (`deepgram(...)`) lives in
-* `sdk/providers/stt/deepgram.ts`. This module is the host-side
-* counterpart: it takes the descriptor options + an API key and
-* returns an {@link SttOpener} that the pipeline session drives.
-*
-* Default model: `"nova-3"`. Any string is forwarded verbatim to the SDK.
-*
-* This adapter targets the Deepgram SDK v5 (`@deepgram/sdk@^5`). The v5
-* streaming API is:
-*   `client.listen.v1.connect(args)` → `Promise<V1Socket>`
-* followed by:
-*   `socket.connect()` + `socket.waitForOpen()` to establish the connection.
-*/
-/**
-* Handle an incoming Deepgram transcript message, emitting `partial` or
-* `final` events on the emitter. Empty transcripts are silently dropped.
+* Targets Deepgram SDK v5: `client.listen.v1.connect(args)` returns a
+* socket; `socket.connect()` + `socket.waitForOpen()` establish it.
 */
+function errMsg(cause) {
+	return cause instanceof Error ? cause.message : String(cause);
+}
 function handleMessage(data, closed, emitter) {
-	if (closed) return;
-	if (data.type !== "Results") return;
-	const result = data;
-	const text = result.channel?.alternatives?.[0]?.transcript ?? "";
-	if (result.is_final) {
-		if (text.length > 0) emitter.emit("final", text);
-	} else if (text.length > 0) emitter.emit("partial", text);
-}
-/** Wire Deepgram socket events onto the nanoevents emitter. */
+	if (closed || data.type !== "Results") return;
+	const text = data.channel?.alternatives?.[0]?.transcript ?? "";
+	if (text.length === 0) return;
+	emitter.emit(data.is_final ? "final" : "partial", text);
+}
 function wireSocketEvents(connection, emitter, getIsClosed) {
 	connection.on("message", (data) => handleMessage(data, getIsClosed(), emitter));
 	connection.on("error", (err) => {
@@ -562,12 +486,13 @@ function wireSocketEvents(connection, emitter, getIsClosed) {
 		if (code !== void 0 && code !== 1e3) emitter.emit("error", makeSttError("stt_stream_error", `socket closed ${code}`));
 	});
 }
-/** Wire the AbortSignal to the close function. */
 function wireAbortSignal(signal, close) {
-	if (signal.aborted) close();
-	else signal.addEventListener("abort", () => void close(), { once: true });
+	if (signal.aborted) {
+		close();
+		return;
+	}
+	signal.addEventListener("abort", () => void close(), { once: true });
 }
-/** Build an {@link SttOpener} from resolved Deepgram descriptor options. */
 function openDeepgram(opts = {}) {
 	return {
 		name: "deepgram",
@@ -590,7 +515,7 @@ function openDeepgram(opts = {}) {
 					Authorization: apiKey
 				});
 			} catch (cause) {
-				throw makeSttError("stt_connect_failed", `Deepgram STT: connect failed: ${cause instanceof Error ? cause.message : String(cause)}`);
+				throw makeSttError("stt_connect_failed", `Deepgram STT: connect failed: ${errMsg(cause)}`);
 			}
 			const emitter = createNanoEvents();
 			let closed = false;
@@ -599,7 +524,7 @@ function openDeepgram(opts = {}) {
 			try {
 				await connection.waitForOpen();
 			} catch (cause) {
-				throw makeSttError("stt_connect_failed", `Deepgram STT: WebSocket open failed: ${cause instanceof Error ? cause.message : String(cause)}`);
+				throw makeSttError("stt_connect_failed", `Deepgram STT: WebSocket open failed: ${errMsg(cause)}`);
 			}
 			const close = async () => {
 				if (closed) return;
@@ -671,15 +596,15 @@ function openElevenLabs(opts = {}) {
 			}
 			const emitter = createNanoEvents();
 			let closed = false;
-			connection.on(RealtimeEvents.PARTIAL_TRANSCRIPT, (msg) => {
+			function emitTranscript(event, text) {
 				if (closed) return;
-				const text = msg.text ?? "";
-				if (text.length > 0) emitter.emit("partial", text);
+				if (text && text.length > 0) emitter.emit(event, text);
+			}
+			connection.on(RealtimeEvents.PARTIAL_TRANSCRIPT, (msg) => {
+				emitTranscript("partial", msg.text);
 			});
 			connection.on(RealtimeEvents.COMMITTED_TRANSCRIPT, (msg) => {
-				if (closed) return;
-				const text = msg.text ?? "";
-				if (text.length > 0) emitter.emit("final", text);
+				emitTranscript("final", msg.text);
 			});
 			connection.on(RealtimeEvents.ERROR, (payload) => {
 				if (closed) return;
@@ -690,13 +615,13 @@ function openElevenLabs(opts = {}) {
 				if (closed) return;
 				emitter.emit("error", makeSttError("stt_auth_failed", msg.error));
 			});
-			const close = async () => {
+			async function close() {
 				if (closed) return;
 				closed = true;
 				try {
 					connection.close();
 				} catch {}
-			};
+			}
 			if (openOpts.signal.aborted) close();
 			else openOpts.signal.addEventListener("abort", () => void close(), { once: true });
 			return {
@@ -715,32 +640,7 @@ function openElevenLabs(opts = {}) {
 }
 //#endregion
 //#region host/providers/stt/soniox.ts
-/**
-* Soniox real-time STT opener (host-only).
-*
-* The user-facing descriptor factory (`soniox(...)`) lives in
-* `sdk/providers/stt/soniox.ts`. This module is the host-side
-* counterpart: it takes the descriptor options + an API key and
-* returns an {@link SttOpener} that the pipeline session drives.
-*
-* Soniox's published JS client (`@soniox/speech-to-text-web`) is
-* browser-only — it depends on `MediaRecorder` and `getUserMedia`. For
-* server-side use we talk to the WebSocket directly:
-*   `wss://stt-rt.soniox.com/transcribe-websocket`
-*
-* Wire format:
-*   - First text frame: JSON config with api_key, model, audio_format,
-*     sample_rate, num_channels (and optional language hints).
-*   - Subsequent binary frames: 16-bit signed little-endian PCM audio.
-*   - Server replies: JSON `{ tokens: [{ text, is_final }] }` messages.
-*     Final tokens accumulate; non-final tokens are a rolling preview.
-*   - On error: `{ error_code, error_message }`.
-*/
 const SONIOX_WS_URL = "wss://stt-rt.soniox.com/transcribe-websocket";
-/**
-* Walk a batch of Soniox tokens, sending finals into `appendFinal` and
-* returning the concatenated non-finals as a rolling preview string.
-*/
 function consumeTokens(tokens, appendFinal) {
 	let nonFinal = "";
 	for (const tok of tokens) {
@@ -751,7 +651,6 @@ function consumeTokens(tokens, appendFinal) {
 	}
 	return nonFinal;
 }
-/** Resolve once the WebSocket opens; reject on the first error. */
 function waitForOpen$1(ws) {
 	return new Promise((resolve, reject) => {
 		const onOpen = () => {
@@ -766,7 +665,6 @@ function waitForOpen$1(ws) {
 		ws.once("error", onErr);
 	});
 }
-/** Build the initial JSON config frame for a Soniox session. */
 function buildConfigFrame(apiKey, opts, sampleRate) {
 	const config = {
 		api_key: apiKey,
@@ -778,7 +676,6 @@ function buildConfigFrame(apiKey, opts, sampleRate) {
 	if (opts.languageHints && opts.languageHints.length > 0) config.language_hints = [...opts.languageHints];
 	return config;
 }
-/** Parse a Soniox text frame into a {@link SonioxResponse}; returns null on garbage. */
 function parseFrame(raw) {
 	try {
 		return JSON.parse(raw.toString());
@@ -786,12 +683,6 @@ function parseFrame(raw) {
 		return null;
 	}
 }
-/**
-* Handle one server response. Emits `error`, `final`, and `partial` events
-* onto `emitter` based on the token batch and the running `finalBuf`. The
-* caller owns `finalBuf` so it survives across messages and can be flushed
-* on close.
-*/
 function handleResponse(res, emitter, finalBuf) {
 	if (res.error_code !== void 0) {
 		emitter.emit("error", makeSttError("stt_stream_error", `Soniox error ${res.error_code}: ${res.error_message ?? "unknown"}`));
@@ -807,7 +698,6 @@ function handleResponse(res, emitter, finalBuf) {
 	}
 	if (nonFinal.length > 0) emitter.emit("partial", nonFinal);
 }
-/** Build an {@link SttOpener} from resolved Soniox descriptor options. */
 function openSoniox(opts = {}) {
 	return {
 		name: "soniox",
@@ -918,8 +808,7 @@ function openCartesia(opts) {
 			}
 			const emitter = createNanoEvents();
 			let closed = false;
-			/** Mint a fresh context bound to the shared TTSWS connection. */
-			const mintContext = () => ws.context({
+			const audioConfig = {
 				model_id: model,
 				voice: {
 					mode: "id",
@@ -929,39 +818,32 @@ function openCartesia(opts) {
 					container: "raw",
 					encoding: "pcm_s16le",
 					sample_rate: sampleRate
-				},
+				}
+			};
+			const baseRequest = {
+				...audioConfig,
+				language
+			};
+			const mintContext = () => ws.context({
+				...audioConfig,
 				contextId: randomUUID()
 			});
 			let context = mintContext();
-			/**
-			* `doneEmitted` guards against emitting `done` more than once per turn.
-			* Reset whenever a fresh context is minted (i.e. at turn boundaries).
-			*/
 			let doneEmitted = false;
-			/**
-			* After `flush()` or `cancel()`, the current context is done accepting
-			* input. We defer minting a fresh one until the next `sendText()` so
-			* that late audio chunks + Cartesia's real `done` event (both tagged
-			* with the flushed context's id) still pass the filter below. Rotating
-			* eagerly would silently drop all audio still in flight.
-			*/
 			let rotatePending = false;
-			const rotateContext = () => {
+			const rotateIfPending = () => {
+				if (!rotatePending) return;
 				context = mintContext();
 				doneEmitted = false;
 				rotatePending = false;
 			};
-			const rotateIfPending = () => {
-				if (rotatePending) rotateContext();
-			};
 			const emitDoneOnce = () => {
 				if (doneEmitted || closed) return;
 				doneEmitted = true;
 				emitter.emit("done");
 			};
 			ws.on("chunk", (event) => {
-				if (closed) return;
-				if (event.context_id !== context.contextId) return;
+				if (closed || event.context_id !== context.contextId) return;
 				const buf = event.audio;
 				if (!buf || buf.byteLength === 0) return;
 				const evenBytes = buf.byteLength - buf.byteLength % 2;
@@ -970,8 +852,7 @@ function openCartesia(opts) {
 				emitter.emit("audio", pcm);
 			});
 			ws.on("done", (event) => {
-				if (closed) return;
-				if (event.context_id !== context.contextId) return;
+				if (closed || event.context_id !== context.contextId) return;
 				emitDoneOnce();
 			});
 			ws.on("error", (err) => {
@@ -990,19 +871,6 @@ function openCartesia(opts) {
 			};
 			if (openOpts.signal.aborted) close();
 			else openOpts.signal.addEventListener("abort", () => void close(), { once: true });
-			const baseRequest = {
-				model_id: model,
-				voice: {
-					mode: "id",
-					id: voice
-				},
-				output_format: {
-					container: "raw",
-					encoding: "pcm_s16le",
-					sample_rate: sampleRate
-				},
-				language
-			};
 			const ignoreRejection = (_err) => {};
 			return {
 				sendText(text) {
@@ -1044,38 +912,18 @@ function openCartesia(opts) {
 /**
 * Rime TTS opener (host-only).
 *
-* The user-facing descriptor factory (`rime(...)`) lives in
-* `sdk/providers/tts/rime.ts`. This module is the host-side
-* counterpart: it takes the descriptor options + an API key and
-* returns a {@link TtsOpener} that the pipeline session drives.
-*
-* **Protocol.** Connects to Rime's `ws2` JSON WebSocket endpoint
-* (`wss://users-ws.rime.ai/ws2`). Client-to-server messages are JSON:
-*   - `{ "text": "..." }` — append text to the synthesis buffer
-*   - `{ "operation": "clear" }` — drop buffered text (barge-in)
-*   - `{ "operation": "eos" }` — drain buffer, close connection (NOT used
-*     during a session: it would tear down the WS, forcing reconnect per
-*     turn). We force end-of-turn synthesis with a trailing `"."` instead.
-* The server responds with JSON frames:
-*   - `{ type: "chunk", data: <base64 PCM16 LE>, contextId: string | null }`
-*   - `{ type: "timestamps", ... }` (ignored)
-*   - `{ type: "error", message: string }` (surfaced as `tts_stream_error`)
-*
-* **Single long-lived connection per session.** Rime buffers text until it
-* sees terminal punctuation (`.`, `?`, `!`), so we use one WebSocket per
-* `open()` call and reuse it across turns. `clear` resets the buffer
-* between cancellations.
+* Connects to Rime's `ws2` JSON WebSocket endpoint with one long-lived
+* connection per session. Client → server: `{ text }` appends to the
+* synthesis buffer, `{ operation: "clear" }` drops it (barge-in). We never
+* send `eos` since it tears down the WS — `flush()` instead sends a
+* trailing `"."` to force synthesis of any text buffered behind missing
+* terminal punctuation while keeping the connection reusable.
 *
-* **Done detection.** After `flush()` sends a trailing `"."` to force the
-* server to synthesize any half-buffered text, we arm a quiescence timer
-* that fires 500 ms after the last received audio chunk. When it fires,
-* `done` is emitted.
-*
-* **Audio format.** The URL requests `audioFormat=pcm` at the negotiated
-* `sampleRate`, which returns raw PCM16 little-endian. We decode the base64
-* payload and construct a zero-copy `Int16Array` view over the decoded bytes.
+* Server → client: `{ type: "chunk", data: <base64 PCM16 LE> }` carries
+* audio; `timestamps` is ignored; `error` surfaces as `tts_stream_error`.
+* The `audioFormat=pcm` query param at the negotiated `sampleRate` returns
+* raw PCM16 LE that we view as a zero-copy `Int16Array`.
 */
-/** PCM16 sample rates accepted by the Rime `ws2` endpoint. */
 const RIME_PCM16_RATES = [
 	8e3,
 	16e3,
@@ -1088,31 +936,14 @@ function assertSupportedSampleRate(rate) {
 	if (RIME_PCM16_RATES.includes(rate)) return rate;
 	throw makeTtsError("tts_connect_failed", `Rime TTS: unsupported sample rate ${rate}. Supported: ${RIME_PCM16_RATES.join(", ")}.`);
 }
-/**
-* Decode a base64 string from Rime into a zero-copy `Int16Array`.
-*
-* Rime's `ws2` endpoint returns base64-encoded PCM16 LE in each chunk.
-* `Buffer.from(base64, "base64")` gives us a Node.js Buffer (which is a
-* Uint8Array subclass) with `byteOffset === 0`. PCM16 bytes always come in
-* pairs so the length is guaranteed to be even.
-*/
 function base64ToPcm(data) {
 	const bytes = Buffer.from(data, "base64");
 	const evenLen = bytes.byteLength - bytes.byteLength % 2;
 	if (evenLen === 0) return new Int16Array(0);
 	return new Int16Array(bytes.buffer, bytes.byteOffset, evenLen / 2);
 }
-/** Quiescence timeout in ms — how long to wait after the last audio chunk before emitting `done`. */
 const QUIESCENCE_MS = 500;
-/**
-* After `flush()`, how long to wait for the FIRST audio chunk before
-* giving up and emitting `done`. Greeting and short replies hit this
-* path: `flush()` runs immediately after `sendText()`, so audio TTFB
-* exceeds the 500 ms quiescence window. Once the first chunk arrives,
-* we transition to the shorter quiescence timeout.
-*/
 const FIRST_AUDIO_TIMEOUT_MS = 5e3;
-/** Wait for the WebSocket `open` event; reject on first `error`. */
 function waitForOpen(ws) {
 	return new Promise((resolve, reject) => {
 		const onOpen = () => {
@@ -1127,12 +958,6 @@ function waitForOpen(ws) {
 		ws.once("error", onError);
 	});
 }
-/**
-* Handle one incoming WebSocket message frame.
-*
-* Extracted into a top-level function to keep `open()` under the cognitive
-* complexity limit while retaining full access to the session state via refs.
-*/
 function handleRimeMessage(raw, emitter, armQuiescence, isActiveTimer) {
 	let msg;
 	try {
@@ -1150,7 +975,6 @@ function handleRimeMessage(raw, emitter, armQuiescence, isActiveTimer) {
 	}
 	if (msg.type === "error") emitter.emit("error", makeTtsError("tts_stream_error", `Rime TTS: ${msg.message ?? "unknown error"}`));
 }
-/** Build a {@link TtsOpener} from resolved Rime descriptor options. */
 function openRime(opts) {
 	return {
 		name: "rime",
@@ -1172,12 +996,6 @@ function openRime(opts) {
 			const emitter = createNanoEvents();
 			let closed = false;
 			let doneEmitted = false;
-			/**
-			* After `flush()`, we arm a timer that fires `done`. Initial timeout is
-			* `FIRST_AUDIO_TIMEOUT_MS` to give Rime headroom on TTFB; the first
-			* chunk swaps it for a shorter `QUIESCENCE_MS` window that resets on
-			* each subsequent chunk. `cancel()` emits `done` synchronously.
-			*/
 			let quiescenceTimer = null;
 			const clearQuiescence = () => {
 				if (quiescenceTimer !== null) {
@@ -1271,21 +1089,24 @@ function openRime(opts) {
 function resolveApiKey(envVar, env) {
 	return env[envVar] ?? process.env[envVar] ?? "";
 }
+function options(descriptor) {
+	return descriptor.options;
+}
 /** Resolve an {@link SttProvider} descriptor into a host-side opener. */
 function resolveStt(descriptor) {
 	switch (descriptor.kind) {
-		case ASSEMBLYAI_KIND: return openAssemblyAI(descriptor.options);
-		case DEEPGRAM_KIND: return openDeepgram(descriptor.options);
-		case ELEVENLABS_KIND: return openElevenLabs(descriptor.options);
-		case SONIOX_KIND: return openSoniox(descriptor.options);
+		case ASSEMBLYAI_KIND: return openAssemblyAI(options(descriptor));
+		case DEEPGRAM_KIND: return openDeepgram(options(descriptor));
+		case ELEVENLABS_KIND: return openElevenLabs(options(descriptor));
+		case SONIOX_KIND: return openSoniox(options(descriptor));
 		default: throw new Error(`Unknown STT provider kind: "${descriptor.kind}". Supported: ${ASSEMBLYAI_KIND}, ${DEEPGRAM_KIND}, ${ELEVENLABS_KIND}, ${SONIOX_KIND}.`);
 	}
 }
 /** Resolve a {@link TtsProvider} descriptor into a host-side opener. */
 function resolveTts(descriptor) {
 	switch (descriptor.kind) {
-		case CARTESIA_KIND: return openCartesia(descriptor.options);
-		case RIME_KIND: return openRime(descriptor.options);
+		case CARTESIA_KIND: return openCartesia(options(descriptor));
+		case RIME_KIND: return openRime(options(descriptor));
 		default: throw new Error(`Unknown TTS provider kind: "${descriptor.kind}". Supported: ${CARTESIA_KIND}, ${RIME_KIND}.`);
 	}
 }
@@ -1302,12 +1123,12 @@ function resolveLlm(descriptor, env) {
 		case ANTHROPIC_KIND: return createAnthropic({
 			apiKey: requireKey(env, "ANTHROPIC_API_KEY", "Anthropic"),
 			baseURL: "https://api.anthropic.com/v1"
-		})(descriptor.options.model);
-		case OPENAI_KIND: return createOpenAI({ apiKey: requireKey(env, "OPENAI_API_KEY", "OpenAI") })(descriptor.options.model);
-		case GOOGLE_KIND: return createGoogleGenerativeAI({ apiKey: requireKey(env, "GOOGLE_GENERATIVE_AI_API_KEY", "Google") })(descriptor.options.model);
-		case MISTRAL_KIND: return createMistral({ apiKey: requireKey(env, "MISTRAL_API_KEY", "Mistral") })(descriptor.options.model);
-		case "xai": return createXai({ apiKey: requireKey(env, "XAI_API_KEY", "xAI") })(descriptor.options.model);
-		case GROQ_KIND: return createGroq({ apiKey: requireKey(env, "GROQ_API_KEY", "Groq") })(descriptor.options.model);
+		})(options(descriptor).model);
+		case OPENAI_KIND: return createOpenAI({ apiKey: requireKey(env, "OPENAI_API_KEY", "OpenAI") })(options(descriptor).model);
+		case GOOGLE_KIND: return createGoogleGenerativeAI({ apiKey: requireKey(env, "GOOGLE_GENERATIVE_AI_API_KEY", "Google") })(options(descriptor).model);
+		case MISTRAL_KIND: return createMistral({ apiKey: requireKey(env, "MISTRAL_API_KEY", "Mistral") })(options(descriptor).model);
+		case "xai": return createXai({ apiKey: requireKey(env, "XAI_API_KEY", "xAI") })(options(descriptor).model);
+		case GROQ_KIND: return createGroq({ apiKey: requireKey(env, "GROQ_API_KEY", "Groq") })(options(descriptor).model);
 		default: throw new Error(`Unknown LLM provider kind: "${descriptor.kind}". Supported: ${ANTHROPIC_KIND}, ${OPENAI_KIND}, ${GOOGLE_KIND}, ${MISTRAL_KIND}, xai, ${GROQ_KIND}.`);
 	}
 }
@@ -1321,8 +1142,9 @@ function loadProviderPackage(name, label) {
 	try {
 		return requireFromHere(name);
 	} catch (err) {
-		if (err instanceof Error && (err.code === "MODULE_NOT_FOUND" || err.code === "ERR_MODULE_NOT_FOUND") && err.message.includes(name)) throw new Error(`${label}: package \`${name}\` is not installed. Run \`pnpm add ${name}\`.`, { cause: err });
-		throw err;
+		const code = err?.code;
+		if (!(err instanceof Error && (code === "MODULE_NOT_FOUND" || code === "ERR_MODULE_NOT_FOUND") && err.message.includes(name))) throw err;
+		throw new Error(`${label}: package \`${name}\` is not installed. Run \`pnpm add ${name}\`.`, { cause: err });
 	}
 }
 function requireKey(env, name, label) {
@@ -1334,67 +1156,42 @@ function requireKey(env, name, label) {
 //#region host/pinecone-vector.ts
 function createPineconeVector(opts) {
 	const { Pinecone } = loadProviderPackage("@pinecone-database/pinecone", "Pinecone Vector");
-	const client = new Pinecone({ apiKey: opts.apiKey });
-	const ns = () => client.index(opts.index).namespace(opts.namespace);
+	const ns = new Pinecone({ apiKey: opts.apiKey }).index(opts.index).namespace(opts.namespace);
 	return {
 		async upsert(id, text, metadata) {
-			const record = {
+			await ns.upsertRecords([{
 				_id: id,
 				text,
 				...metadata ?? {}
-			};
-			await ns().upsertRecords([record]);
+			}]);
 		},
 		async query(text, queryOpts) {
-			const topK = queryOpts?.topK ?? 5;
-			const req = {
+			const { topK = 5, filter } = queryOpts ?? {};
+			return (await ns.searchRecords({
 				query: {
 					inputs: { text },
 					topK,
-					...queryOpts?.filter !== void 0 ? { filter: queryOpts.filter } : {}
+					...filter !== void 0 ? { filter } : {}
 				},
 				fields: ["*"]
-			};
-			return (await ns().searchRecords(req)).result.hits.map((hit) => {
+			})).result.hits.map((hit) => {
 				const { text: hitText, ...rest } = hit.fields;
-				const metadata = Object.keys(rest).length > 0 ? rest : void 0;
-				return {
+				const match = {
 					id: hit._id,
 					score: hit._score,
-					text: typeof hitText === "string" ? hitText : "",
-					...metadata !== void 0 ? { metadata } : {}
+					text: typeof hitText === "string" ? hitText : ""
 				};
+				if (Object.keys(rest).length > 0) match.metadata = rest;
+				return match;
 			});
 		},
 		async delete(ids) {
-			const list = Array.isArray(ids) ? ids : [ids];
-			await ns().deleteMany(list);
+			await ns.deleteMany(Array.isArray(ids) ? ids : [ids]);
 		}
 	};
 }
 //#endregion
 //#region host/unstorage-kv.ts
-/**
-* Key-value store backed by unstorage.
-*
-* Works with any unstorage driver (memory, fs, S3/R2, etc.).
-*/
-/**
-* Create a KV store backed by any unstorage driver.
-*
-* @param options - See {@link UnstorageKvOptions}.
-* @returns A {@link Kv} instance.
-*
-* @example
-* ```ts
-* import { createStorage } from "unstorage";
-* import { createUnstorageKv } from "@alexkroman1/aai/unstorage-kv";
-*
-* const kv = createUnstorageKv({ storage: createStorage() });
-* await kv.set("greeting", "hello");
-* const value = await kv.get<string>("greeting"); // "hello"
-* ```
-*/
 function createUnstorageKv(options) {
 	const store = options.prefix ? prefixStorage(options.storage, options.prefix) : options.storage;
 	return {
@@ -1403,9 +1200,9 @@ function createUnstorageKv(options) {
 		},
 		async set(key, value, setOptions) {
 			if (JSON.stringify(value).length > 65536) throw new Error(`Value exceeds max size of ${MAX_VALUE_SIZE} bytes`);
-			const storable = value;
-			if (setOptions?.expireIn && setOptions.expireIn > 0) await store.setItem(key, storable, { ttl: Math.ceil(setOptions.expireIn / 1e3) });
-			else await store.setItem(key, storable);
+			const expireIn = setOptions?.expireIn;
+			const ttlOption = expireIn && expireIn > 0 ? { ttl: Math.ceil(expireIn / 1e3) } : void 0;
+			await store.setItem(key, value, ttlOption);
 		},
 		async delete(keys) {
 			const keyArray = Array.isArray(keys) ? keys : [keys];
@@ -1418,36 +1215,15 @@ function createUnstorageKv(options) {
 }
 //#endregion
 //#region host/providers/resolve-kv.ts
-/**
-* Descriptor → concrete `Kv` resolver. Mirror of `resolveLlm` /
-* `resolveVector`. Always wraps the produced unstorage Storage in
-* `createUnstorageKv` with the provided per-tenant prefix so namespace
-* isolation is enforced regardless of backend choice.
-*/
-/**
-* Load a CJS unstorage driver factory. The CJS variants use
-* `module.exports = defineDriver(...)` so the require result is the
-* factory itself (not an object with `.default`).
-*
-* Delegates to loadProviderPackage (lazy-load via createRequire so the
-* driver is a true optional peer dep).
-*/
 function loadDriver(modulePath, label) {
 	return loadProviderPackage(modulePath, `${label} KV: driver`);
 }
-/**
-* Build a lazy unstorage Driver that defers loading the real driver
-* factory until the first I/O operation. This is necessary for drivers
-* whose peer dependencies (e.g. `ioredis`) may not be installed on the
-* host at startup — the missing package will only surface when the agent
-* actually performs KV operations, not at session creation time.
-*/
 function makeLazyDriver(modulePath, label, opts) {
 	let resolved = null;
-	const get = () => {
+	function get() {
 		if (!resolved) resolved = loadDriver(modulePath, label)(opts);
 		return resolved;
-	};
+	}
 	return {
 		name: label.toLowerCase(),
 		hasItem: (key, txOpts) => get().hasItem(key, txOpts),
@@ -1458,10 +1234,9 @@ function makeLazyDriver(modulePath, label, opts) {
 		removeItem: (key, txOpts) => get().removeItem?.(key, txOpts),
 		getKeys: (base, txOpts) => get().getKeys(base, txOpts),
 		clear: (base, txOpts) => get().clear?.(base, txOpts),
-		dispose: () => resolved ? resolved.dispose?.() : void 0
+		dispose: () => resolved?.dispose?.()
 	};
 }
-/** Resolve a {@link KvProvider} descriptor into a {@link Kv}. */
 function resolveKv(descriptor, env, prefix) {
 	switch (descriptor.kind) {
 		case MEMORY_KV_KIND: return createUnstorageKv({
@@ -1508,24 +1283,16 @@ function resolveKv(descriptor, env, prefix) {
 }
 //#endregion
 //#region host/providers/resolve-vector.ts
-/**
-* Descriptor → concrete `Vector` resolver. Mirror of `resolveLlm`.
-*
-* Pulls API keys from the agent env so descriptors stay
-* secret-free. Lazy-loads provider SDKs via `createRequire` so
-* unused providers never enter the bundle.
-*/
-/** Resolve a {@link VectorProvider} descriptor into a {@link Vector}. */
 function resolveVector(descriptor, env, namespace) {
 	switch (descriptor.kind) {
 		case IN_MEMORY_VECTOR_KIND: return createMemoryVector({ namespace });
 		case PINECONE_VECTOR_KIND: {
 			const apiKey = resolveApiKey("PINECONE_API_KEY", env);
 			if (!apiKey) throw new Error("Pinecone Vector: missing API key. Set PINECONE_API_KEY in the agent env.");
-			const opts = descriptor.options;
+			const { index } = descriptor.options;
 			return createPineconeVector({
 				apiKey,
-				index: opts.index,
+				index,
 				namespace
 			});
 		}
@@ -1534,14 +1301,13 @@ function resolveVector(descriptor, env, namespace) {
 }
 //#endregion
 //#region sdk/system-prompt.ts
-function getFormattedDate() {
-	return (/* @__PURE__ */ new Date()).toLocaleDateString("en-US", {
-		weekday: "long",
-		year: "numeric",
-		month: "long",
-		day: "numeric"
-	});
-}
+const DATE_FORMAT_OPTIONS = {
+	weekday: "long",
+	year: "numeric",
+	month: "long",
+	day: "numeric"
+};
+const TOOL_PREAMBLE = "\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 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.
@@ -1557,11 +1323,10 @@ const VOICE_RULES = "\n\nCRITICAL OUTPUT RULES — you MUST follow these for EVE
 * @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 toolPreamble = opts.hasTools ? TOOL_PREAMBLE : "";
 	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 : "");
+	return DEFAULT_SYSTEM_PROMPT + `\n\nToday's date is ${(/* @__PURE__ */ new Date()).toLocaleDateString("en-US", DATE_FORMAT_OPTIONS)}.` + agentInstructions + toolPreamble + guidance + (opts.voice ? VOICE_RULES : "");
 }
 //#endregion
 //#region host/runtime-config.ts
@@ -1581,22 +1346,23 @@ const consoleLogger = {
 	error: consoleLog(console.error),
 	debug: consoleLog(console.debug)
 };
-/**
-* Structured JSON logger for production diagnostics. Each log entry is a
-* single-line JSON object with `timestamp`, `level`, `msg`, and any
-* caller-provided context fields.
-*/
 function jsonLog(level) {
+	const out = level === "error" || level === "warn" ? process.stderr : process.stdout;
 	return (msg, ctx) => {
 		const entry = {
 			timestamp: (/* @__PURE__ */ new Date()).toISOString(),
 			level,
-			msg
+			msg,
+			...ctx
 		};
-		if (ctx) Object.assign(entry, ctx);
-		(level === "error" || level === "warn" ? process.stderr : process.stdout).write(`${JSON.stringify(entry)}\n`);
+		out.write(`${JSON.stringify(entry)}\n`);
 	};
 }
+/**
+* Structured JSON logger for production diagnostics. Each log entry is a
+* single-line JSON object with `timestamp`, `level`, `msg`, and any
+* caller-provided context fields.
+*/
 const jsonLogger = {
 	info: jsonLog("info"),
 	warn: jsonLog("warn"),
@@ -1615,15 +1381,16 @@ const REPLY_DONE_SLOW_THRESHOLD_MS = 50;
 function createSessionCore(opts) {
 	const log = opts.logger ?? consoleLogger;
 	const maxHistory = opts.maxHistory ?? 200;
-	const idleMs = (() => {
-		const raw = opts.agentConfig.idleTimeoutMs ?? 3e5;
-		return raw === 0 || !Number.isFinite(raw) ? 0 : raw;
-	})();
-	let reply = {
-		currentReplyId: null,
-		pendingTools: [],
-		toolCallCount: 0
-	};
+	const rawIdleMs = opts.agentConfig.idleTimeoutMs ?? 3e5;
+	const idleMs = rawIdleMs === 0 || !Number.isFinite(rawIdleMs) ? 0 : rawIdleMs;
+	function emptyReply() {
+		return {
+			currentReplyId: null,
+			pendingTools: [],
+			toolCallCount: 0
+		};
+	}
+	let reply = emptyReply();
 	let history = [];
 	let turnPromise = null;
 	let idleTimer = null;
@@ -1645,18 +1412,13 @@ function createSessionCore(opts) {
 	}
 	function beginReply(replyId) {
 		reply = {
-			currentReplyId: replyId,
-			pendingTools: [],
-			toolCallCount: 0
+			...emptyReply(),
+			currentReplyId: replyId
 		};
 		turnPromise = null;
 	}
 	function cancelReply() {
-		reply = {
-			currentReplyId: null,
-			pendingTools: [],
-			toolCallCount: 0
-		};
+		reply = emptyReply();
 	}
 	function flushReply(startMs, hadTurnPromise) {
 		const stepsUsed = reply.toolCallCount;
@@ -1846,7 +1608,7 @@ function createSessionCore(opts) {
 */
 const yieldTick = () => new Promise((r) => setTimeout(r, 0));
 function buildToolContext(opts) {
-	const { env, state, kv, vector, messages, sessionId } = opts;
+	const { env, state, kv, vector, messages, sessionId, send } = opts;
 	return {
 		env,
 		state: state ?? {},
@@ -1861,14 +1623,21 @@ function buildToolContext(opts) {
 		messages: messages ?? [],
 		sessionId: sessionId ?? "",
 		send(event, data) {
-			opts.send?.(event, data);
+			send?.(event, data);
 		}
 	};
 }
+function formatZodIssues(error) {
+	return (error?.issues ?? []).map((i) => `${i.path.map(String).join(".")}: ${i.message}`).join(", ");
+}
+function stringifyResult(result) {
+	if (result == null) return "null";
+	return typeof result === "string" ? result : JSON.stringify(result);
+}
 async function executeToolCall(name, args, options) {
-	const { tool } = options;
+	const { tool, logger } = options;
 	const parsed = (tool.parameters ?? EMPTY_PARAMS).safeParse(args);
-	if (!parsed.success) return toolError(`Invalid arguments for tool "${name}": ${(parsed.error?.issues ?? []).map((i) => `${i.path.map(String).join(".")}: ${i.message}`).join(", ")}`);
+	if (!parsed.success) return toolError(`Invalid arguments for tool "${name}": ${formatZodIssues(parsed.error)}`);
 	try {
 		const ctx = buildToolContext(options);
 		await yieldTick();
@@ -1877,11 +1646,9 @@ async function executeToolCall(name, args, options) {
 			message: `Tool "${name}" timed out after ${TOOL_EXECUTION_TIMEOUT_MS}ms`
 		});
 		await yieldTick();
-		if (result == null) return "null";
-		return typeof result === "string" ? result : JSON.stringify(result);
+		return stringifyResult(result);
 	} catch (err) {
-		const log = options.logger;
-		if (log) log.warn("Tool execution failed", {
+		if (logger) logger.warn("Tool execution failed", {
 			tool: name,
 			error: errorDetail(err)
 		});
@@ -1890,29 +1657,267 @@ async function executeToolCall(name, args, options) {
 	}
 }
 //#endregion
+//#region host/_base64.ts
+function uint8ToBase64(bytes) {
+	return Buffer.from(bytes).toString("base64");
+}
+function base64ToUint8(base64) {
+	return new Uint8Array(Buffer.from(base64, "base64"));
+}
+//#endregion
+//#region host/transports/openai-realtime-transport.ts
+const DEFAULT_MODEL = "gpt-realtime-2";
+const DEFAULT_VOICE = "alloy";
+const DEFAULT_URL = "wss://api.openai.com/v1/realtime";
+const defaultCreateOpenaiRealtimeWebSocket = (url, opts) => new WsWebSocket(url, { headers: opts.headers });
+function createOpenaiRealtimeTransport(opts) {
+	const log = opts.logger ?? consoleLogger;
+	const createWs = opts.createWebSocket ?? defaultCreateOpenaiRealtimeWebSocket;
+	const model = opts.options.model ?? DEFAULT_MODEL;
+	const voice = opts.options.voice ?? DEFAULT_VOICE;
+	const baseUrl = opts.options.url ?? DEFAULT_URL;
+	let ws = null;
+	let closing = false;
+	const agentTranscriptBuffers = /* @__PURE__ */ new Map();
+	const toolBuffers = /* @__PURE__ */ new Map();
+	let currentResponseId = null;
+	function send(payload) {
+		if (!ws || ws.readyState !== 1) {
+			log.debug("OpenAI Realtime send dropped: socket not open", { type: payload.type });
+			return;
+		}
+		ws.send(JSON.stringify(payload));
+	}
+	function sendSessionUpdate() {
+		send({
+			type: "session.update",
+			session: {
+				modalities: ["audio", "text"],
+				voice,
+				instructions: opts.sessionConfig.systemPrompt,
+				input_audio_format: "pcm16",
+				output_audio_format: "pcm16",
+				input_audio_transcription: { model: "whisper-1" },
+				turn_detection: { type: "server_vad" },
+				tools: opts.toolSchemas,
+				tool_choice: opts.toolChoice
+			}
+		});
+	}
+	async function start() {
+		const url = `${baseUrl}?model=${encodeURIComponent(model)}`;
+		log.info("OpenAI Realtime connecting", { url });
+		return new Promise((resolve, reject) => {
+			const sock = createWs(url, { headers: {
+				Authorization: `Bearer ${opts.apiKey}`,
+				"OpenAI-Beta": "realtime=v1"
+			} });
+			ws = sock;
+			let opened = false;
+			sock.addEventListener("open", () => {
+				opened = true;
+				sendSessionUpdate();
+				resolve();
+			});
+			sock.addEventListener("message", (ev) => handleMessage(ev.data));
+			sock.addEventListener("close", (ev) => handleClose(ev.code ?? 0, ev.reason ?? ""));
+			sock.addEventListener("error", (ev) => {
+				const msg = typeof ev.message === "string" ? ev.message : "WebSocket error";
+				if (!opened) {
+					reject(new Error(msg));
+					return;
+				}
+				if (closing) {
+					log.info("OpenAI Realtime error during close", { error: msg });
+					return;
+				}
+				opts.callbacks.onError("internal", msg);
+			});
+		});
+	}
+	function asString(v) {
+		return typeof v === "string" ? v : "";
+	}
+	function handleAudioDelta(obj) {
+		if (typeof obj.delta === "string") opts.callbacks.onAudioChunk(base64ToUint8(obj.delta));
+	}
+	function handleUserTranscript(obj) {
+		if (typeof obj.transcript === "string") opts.callbacks.onUserTranscript(obj.transcript);
+	}
+	function handleResponseCreated(obj) {
+		const resp = obj.response;
+		const id = asString(resp?.id);
+		currentResponseId = id;
+		opts.callbacks.onReplyStarted(id);
+	}
+	function handleAgentTranscriptDelta(obj) {
+		const id = asString(obj.item_id);
+		const delta = asString(obj.delta);
+		agentTranscriptBuffers.set(id, (agentTranscriptBuffers.get(id) ?? "") + delta);
+	}
+	function handleAgentTranscriptDone(obj) {
+		const id = asString(obj.item_id);
+		const text = agentTranscriptBuffers.get(id) ?? "";
+		agentTranscriptBuffers.delete(id);
+		if (text) opts.callbacks.onAgentTranscript(text, false);
+	}
+	function clearTurnBuffers() {
+		agentTranscriptBuffers.clear();
+		toolBuffers.clear();
+	}
+	function handleResponseDone() {
+		currentResponseId = null;
+		clearTurnBuffers();
+		opts.callbacks.onReplyDone();
+	}
+	function handleErrorEvent(obj) {
+		const err = obj.error;
+		const message = typeof err?.message === "string" ? err.message : "OpenAI Realtime error";
+		clearTurnBuffers();
+		opts.callbacks.onError("internal", message);
+	}
+	function handleOutputItemAdded(obj) {
+		const item = obj.item;
+		if (item?.type !== "function_call" || !item.id) return;
+		toolBuffers.set(item.id, {
+			callId: item.call_id ?? "",
+			name: item.name ?? "",
+			argsBuffer: ""
+		});
+	}
+	function handleFunctionCallArgsDelta(obj) {
+		const id = asString(obj.item_id);
+		const delta = asString(obj.delta);
+		const buf = toolBuffers.get(id);
+		if (buf) buf.argsBuffer += delta;
+	}
+	function parseToolArgs(argsStr, name, callId) {
+		if (!argsStr) return {};
+		try {
+			const parsed = JSON.parse(argsStr);
+			if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) return parsed;
+		} catch {
+			log.warn("OpenAI Realtime: invalid tool args JSON", {
+				name,
+				callId
+			});
+		}
+		return {};
+	}
+	function handleFunctionCallArgsDone(obj) {
+		const id = asString(obj.item_id);
+		const buf = toolBuffers.get(id);
+		toolBuffers.delete(id);
+		const callId = asString(obj.call_id) || (buf?.callId ?? "");
+		const name = asString(obj.name) || (buf?.name ?? "");
+		const args = parseToolArgs(asString(obj.arguments) || (buf?.argsBuffer ?? ""), name, callId);
+		opts.callbacks.onToolCall(callId, name, args);
+	}
+	function handleMessage(data) {
+		let raw;
+		try {
+			raw = JSON.parse(String(data));
+		} catch {
+			log.warn("OpenAI Realtime: invalid JSON");
+			return;
+		}
+		if (typeof raw !== "object" || raw === null) return;
+		const obj = raw;
+		switch (obj.type) {
+			case "response.audio.delta":
+				handleAudioDelta(obj);
+				return;
+			case "response.audio.done":
+				opts.callbacks.onAudioDone();
+				return;
+			case "input_audio_buffer.speech_started":
+				opts.callbacks.onSpeechStarted();
+				return;
+			case "input_audio_buffer.speech_stopped":
+				opts.callbacks.onSpeechStopped();
+				return;
+			case "conversation.item.input_audio_transcription.completed":
+				handleUserTranscript(obj);
+				return;
+			case "response.created":
+				handleResponseCreated(obj);
+				return;
+			case "response.audio_transcript.delta":
+				handleAgentTranscriptDelta(obj);
+				return;
+			case "response.audio_transcript.done":
+				handleAgentTranscriptDone(obj);
+				return;
+			case "response.done":
+				handleResponseDone();
+				return;
+			case "response.output_item.added":
+				handleOutputItemAdded(obj);
+				return;
+			case "response.function_call_arguments.delta":
+				handleFunctionCallArgsDelta(obj);
+				return;
+			case "response.function_call_arguments.done":
+				handleFunctionCallArgsDone(obj);
+				return;
+			case "error":
+				handleErrorEvent(obj);
+				return;
+			default: return;
+		}
+	}
+	function handleClose(code, reason) {
+		if (closing) {
+			log.info("OpenAI Realtime closed", {
+				code,
+				reason
+			});
+			return;
+		}
+		log.warn("OpenAI Realtime closed unexpectedly", {
+			code,
+			reason
+		});
+		opts.callbacks.onError("connection", `OpenAI Realtime closed (code=${code})`);
+	}
+	async function stop() {
+		closing = true;
+		ws?.close();
+		ws = null;
+	}
+	return {
+		start,
+		stop,
+		sendUserAudio(bytes) {
+			if (!ws || ws.readyState !== 1) return;
+			ws.send(`{"type":"input_audio_buffer.append","audio":"${uint8ToBase64(bytes)}"}`);
+		},
+		sendToolResult(callId, result) {
+			send({
+				type: "conversation.item.create",
+				item: {
+					type: "function_call_output",
+					call_id: callId,
+					output: result
+				}
+			});
+			send({ type: "response.create" });
+		},
+		cancelReply() {
+			if (currentResponseId === null) return;
+			send({ type: "response.cancel" });
+			currentResponseId = null;
+			clearTurnBuffers();
+			opts.callbacks.onCancelled();
+		}
+	};
+}
+//#endregion
 //#region host/to-vercel-tools.ts
 /**
-* Converts agent {@link ToolSchema}[] to Vercel AI SDK tools with `execute`
-* delegation to the agent's {@link ExecuteTool} function.
-*
-* 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.
-*
-* 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.
-*/
-/**
-* 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.
+* Converts agent {@link ToolSchema}[] to Vercel AI SDK tools, delegating
+* `execute` to the agent's {@link ExecuteTool} so validation, KV, hooks,
+* and timeouts remain the single source of truth for tool behavior.
 */
 function toVercelTools(schemas, ctx) {
 	const out = {};
@@ -1925,7 +1930,8 @@ function toVercelTools(schemas, ctx) {
 			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().slice(), opts);
+			const history = ctx.messages().slice();
+			return ctx.executeTool(schema.name, input, ctx.sessionId, history, opts);
 		}
 	});
 	return out;
@@ -1976,10 +1982,6 @@ function createPipelineTransport(opts) {
 	function emitError(code, message) {
 		callbacks.onError(code, message);
 	}
-	/**
-	* Tear down after an unrecoverable provider error. Aborts the in-flight
-	* turn, cancels TTS, signals providers to close. Idempotent.
-	*/
 	function terminate() {
 		if (terminated) return;
 		terminated = true;
@@ -2115,16 +2117,10 @@ function createPipelineTransport(opts) {
 			}
 		};
 	}
-	/**
-	* Flush TTS and wait for drain. Resolves on:
-	*   - TTS emits `done`
-	*   - `signal` aborts (barge-in / provider error / session stop)
-	*   - PIPELINE_FLUSH_TIMEOUT_MS elapses
-	* Resolves immediately if no TTS session.
-	*/
 	function flushTtsAndWait(signal) {
 		const tts = ttsSession;
 		if (!tts) return Promise.resolve();
+		if (signal.aborted) return Promise.resolve();
 		return new Promise((resolve) => {
 			let off = null;
 			let timer = null;
@@ -2144,10 +2140,6 @@ function createPipelineTransport(opts) {
 				resolve();
 			};
 			const onAbort = () => finish();
-			if (signal.aborted) {
-				resolve();
-				return;
-			}
 			signal.addEventListener("abort", onAbort, { once: true });
 			off = tts.on("done", finish);
 			timer = setTimeout(() => {
@@ -2301,8 +2293,7 @@ function createPipelineTransport(opts) {
 		},
 		sendUserAudio(bytes) {
 			if (terminated || !audioReady) return;
-			const offset = bytes.byteOffset;
-			const length = bytes.byteLength;
+			const { byteOffset: offset, byteLength: length } = bytes;
 			let pcm;
 			if (offset % 2 === 0 && length % 2 === 0) pcm = new Int16Array(bytes.buffer, offset, length / 2);
 			else {
@@ -2323,15 +2314,16 @@ function createPipelineTransport(opts) {
 }
 //#endregion
 //#region host/s2s.ts
-const uint8ToBase64 = (bytes) => Buffer.from(bytes).toString("base64");
-const base64ToUint8 = (base64) => new Uint8Array(Buffer.from(base64, "base64"));
 const defaultCreateS2sWebSocket = (url, opts) => new WsWebSocket(url, { headers: opts.headers });
 const S2sMessageSchema = z.discriminatedUnion("type", [
 	z.object({
 		type: z.literal("session.ready"),
 		session_id: z.string()
 	}).passthrough(),
-	z.object({ type: z.literal("session.updated") }).passthrough(),
+	z.object({
+		type: z.literal("session.updated"),
+		config: z.object({ id: z.string().optional() }).passthrough().optional()
+	}).passthrough(),
 	z.object({ type: z.literal("input.speech.started") }),
 	z.object({ type: z.literal("input.speech.stopped") }),
 	z.object({
@@ -2374,12 +2366,17 @@ function parseS2sMessage(obj) {
 	const result = S2sMessageSchema.safeParse(obj);
 	return result.success ? result.data : void 0;
 }
+function sidFields(ctx) {
+	return ctx.sid !== void 0 ? { sid: ctx.sid } : {};
+}
 function dispatchS2sMessage(callbacks, msg, state, ctx) {
 	switch (msg.type) {
 		case "session.ready":
 			callbacks.onSessionReady(msg.session_id);
 			break;
-		case "session.updated": break;
+		case "session.updated":
+			if (msg.config?.id !== void 0) callbacks.onSessionReady(msg.config.id);
+			break;
 		case "input.speech.started":
 			if (!state.speechActive) {
 				state.speechActive = true;
@@ -2406,13 +2403,18 @@ function dispatchS2sMessage(callbacks, msg, state, ctx) {
 			break;
 		case "reply.done":
 			ctx.log.info("S2S << reply.done", {
-				...ctx.sid !== void 0 ? { sid: ctx.sid } : {},
+				...sidFields(ctx),
 				status: msg.status ?? "completed"
 			});
 			if (msg.status === "interrupted") callbacks.onCancelled();
 			else callbacks.onReplyDone();
 			break;
 		case "session.error":
+			ctx.log.warn("S2S << session.error", {
+				...sidFields(ctx),
+				code: msg.code,
+				message: msg.message
+			});
 			if (msg.code === "session_not_found" || msg.code === "session_forbidden") callbacks.onSessionExpired();
 			else callbacks.onError(new Error(msg.message));
 			break;
@@ -2439,8 +2441,8 @@ function connectS2s(opts) {
 				return;
 			}
 			const json = JSON.stringify(msg);
-			if (msg.type !== "input.audio") if (msg.type === "session.update") log.info(`S2S >> ${msg.type}`, { payload: json });
-			else log.info(`S2S >> ${msg.type}`);
+			if (msg.type === "session.update") log.info(`S2S >> ${msg.type}`, { payload: json });
+			else if (msg.type !== "input.audio") log.info(`S2S >> ${msg.type}`);
 			ws.send(json);
 		}
 		const handle = {
@@ -2489,35 +2491,28 @@ function connectS2s(opts) {
 			log.info("S2S WebSocket open");
 			resolve(handle);
 		});
-		function tryParseJson(data) {
+		function logIncoming(type) {
+			if (type === "reply.audio" || type === "input.audio" || type === "reply.done" || type === "session.error") return;
+			log.info(`S2S << ${type}`);
+		}
+		ws.addEventListener("message", (ev) => {
+			let raw;
 			try {
-				return JSON.parse(String(data));
+				raw = JSON.parse(String(ev.data));
 			} catch {
-				log.warn("S2S << invalid JSON", { data: String(data).slice(0, 200) });
-			}
-		}
-		function handleAudioFastPath(obj) {
-			if (obj.type === "reply.audio" && typeof obj.data === "string") {
-				callbacks.onAudio(base64ToUint8(obj.data));
-				return true;
+				log.warn("S2S << invalid JSON", { data: String(ev.data).slice(0, 200) });
+				return;
 			}
-			return false;
-		}
-		function logIncoming(obj) {
-			if (obj.type === "reply.audio" || obj.type === "input.audio") return;
-			if (obj.type === "reply.done") return;
-			log.info(`S2S << ${obj.type}`);
-		}
-		ws.addEventListener("message", (ev) => {
-			const raw = tryParseJson(ev.data);
-			if (raw === void 0) return;
 			if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
 				log.warn("S2S << non-object JSON message", { type: typeof raw });
 				return;
 			}
 			const obj = raw;
-			logIncoming(obj);
-			if (handleAudioFastPath(obj)) return;
+			logIncoming(obj.type);
+			if (obj.type === "reply.audio" && typeof obj.data === "string") {
+				callbacks.onAudio(base64ToUint8(obj.data));
+				return;
+			}
 			const parsed = parseS2sMessage(obj);
 			if (!parsed) {
 				log.warn(`S2S << unrecognised message type: ${obj.type ?? JSON.stringify(raw).slice(0, 200)}`);
@@ -2550,9 +2545,9 @@ function connectS2s(opts) {
 const _internals = { connectS2s };
 /**
 * Close codes worth attempting `session.resume` on. These are network/server
-* blips, not protocol or auth violations. Per AssemblyAI's docs, sessions are
-* preserved for 30 s after disconnect, so resume is bounded by the window in
-* `RESUME_WINDOW_MS` below.
+* blips, not protocol or auth violations. AssemblyAI keeps the session
+* available for 30 s after disconnect; reconnect runs immediately on close,
+* so the resume request reliably lands inside that window.
 */
 const TRANSIENT_CLOSE_CODES = new Set([
 	1005,
@@ -2560,48 +2555,29 @@ const TRANSIENT_CLOSE_CODES = new Set([
 	1011,
 	3005
 ]);
-/**
-* AssemblyAI keeps the session alive for 30 s after disconnect; we leave a
-* little headroom so the resume request still fits inside that window after
-* the new WebSocket finishes opening.
-*/
-const RESUME_WINDOW_MS = 25e3;
 function createS2sTransport(opts) {
 	const log = opts.logger ?? consoleLogger;
 	const createWs = opts.createWebSocket ?? defaultCreateS2sWebSocket;
 	let handle = null;
 	let currentReplyId = null;
-	/** Most recent `session.ready` ID — present once the upstream session is established. */
 	let providerSessionId = null;
-	/** When the current session became ready; bounds the resume window. */
-	let sessionReadyAt = 0;
-	/** Set by `stop()` so a deliberate close doesn't trigger a reconnect. */
 	let closing = false;
-	/**
-	* True while a `session.resume` round-trip is in flight (between sending
-	* resume and the next `session.ready`). Used to distinguish a resume failure
-	* (close before ready) from a normal close.
-	*/
 	let reconnecting = false;
-	/**
-	* Set when a reconnect attempt is kicked off, cleared once the resumed
-	* session's `session.ready` arrives. Prevents back-to-back reconnect loops
-	* when the freshly-resumed socket also drops before fully recovering.
-	*/
-	let reconnectInFlight = false;
 	function buildCallbacks() {
 		return {
 			onSessionReady: (id) => {
+				const isFirstReady = providerSessionId === null;
 				providerSessionId = id;
-				sessionReadyAt = Date.now();
 				if (reconnecting) {
 					reconnecting = false;
-					reconnectInFlight = false;
 					log.info("S2S resumed", {
 						sid: opts.sid,
 						sessionId: id
 					});
-				}
+				} else if (isFirstReady) log.info("S2S session ready", {
+					sid: opts.sid,
+					sessionId: id
+				});
 				opts.callbacks.onSessionReady?.(id);
 			},
 			onReplyStarted: (replyId) => {
@@ -2625,7 +2601,6 @@ function createS2sTransport(opts) {
 			onSessionExpired: () => {
 				if (reconnecting) {
 					reconnecting = false;
-					reconnectInFlight = false;
 					log.warn("S2S resume rejected: session expired", { sid: opts.sid });
 					opts.callbacks.onError("connection", "S2S resume failed: session expired");
 					return;
@@ -2638,15 +2613,11 @@ function createS2sTransport(opts) {
 		};
 	}
 	function canResumeAfter(code) {
-		if (!TRANSIENT_CLOSE_CODES.has(code)) return false;
-		if (providerSessionId === null) return false;
-		if (reconnectInFlight) return false;
-		return sessionReadyAt > 0 && Date.now() - sessionReadyAt < RESUME_WINDOW_MS;
+		return TRANSIENT_CLOSE_CODES.has(code) && providerSessionId !== null && !reconnecting;
 	}
 	function emitFatalClose(code, reason, wasReconnecting) {
 		if (wasReconnecting) {
 			reconnecting = false;
-			reconnectInFlight = false;
 			opts.callbacks.onError("connection", `S2S resume failed (code=${code})`);
 			return;
 		}
@@ -2667,7 +2638,6 @@ function createS2sTransport(opts) {
 		});
 	}
 	function startResume(prevId, code, reason) {
-		reconnectInFlight = true;
 		reconnecting = true;
 		log.warn("S2S unexpected close — attempting resume", {
 			sid: opts.sid,
@@ -2682,7 +2652,6 @@ function createS2sTransport(opts) {
 		}
 		resume(prevId).catch((err) => {
 			reconnecting = false;
-			reconnectInFlight = false;
 			const msg = err instanceof Error ? err.message : String(err);
 			log.warn("S2S resume failed", {
 				sid: opts.sid,
@@ -2700,12 +2669,11 @@ function createS2sTransport(opts) {
 			return;
 		}
 		const wasReconnecting = reconnecting;
-		if (!canResumeAfter(code)) {
+		const prevId = providerSessionId;
+		if (!canResumeAfter(code) || prevId === null) {
 			emitFatalClose(code, reason, wasReconnecting);
 			return;
 		}
-		const prevId = providerSessionId;
-		if (prevId === null) return;
 		startResume(prevId, code, reason);
 	}
 	async function resume(prevSessionId) {
@@ -2714,7 +2682,7 @@ function createS2sTransport(opts) {
 			config: opts.s2sConfig,
 			createWebSocket: createWs,
 			logger: log,
-			...opts.sid !== void 0 ? { sid: opts.sid } : {},
+			sid: opts.sid,
 			callbacks: buildCallbacks()
 		});
 		if (closing) {
@@ -2799,14 +2767,11 @@ function createClientSink(ws, log) {
 		}
 	};
 }
-function handleBinaryAudio(data, session) {
+function dispatchMessage(data, session, log, sid) {
 	if (data instanceof Uint8Array) {
 		session.onAudio(data);
-		return true;
+		return;
 	}
-	return false;
-}
-function handleTextMessage(data, session, log, sid) {
 	if (typeof data !== "string") {
 		log.warn("ws: non-string, non-binary frame received; dropping", { sid });
 		return;
@@ -2869,10 +2834,7 @@ function wireSessionSocket(ws, opts) {
 		if (!(session && messageBuffer)) return;
 		const buf = messageBuffer;
 		messageBuffer = null;
-		for (const event of buf) {
-			if (handleBinaryAudio(event.data, session)) continue;
-			handleTextMessage(event.data, session, log, sid);
-		}
+		for (const event of buf) dispatchMessage(event.data, session, log, sid);
 	}
 	function onOpen() {
 		opts.onOpen?.();
@@ -2921,8 +2883,7 @@ function wireSessionSocket(ws, opts) {
 			if (messageBuffer && messageBuffer.length < 100) messageBuffer.push(event);
 			return;
 		}
-		if (handleBinaryAudio(event.data, session)) return;
-		handleTextMessage(event.data, session, log, sid);
+		dispatchMessage(event.data, session, log, sid);
 	});
 	ws.addEventListener("close", () => {
 		log.info("Session disconnected", {
@@ -2953,27 +2914,19 @@ function wireSessionSocket(ws, opts) {
 //#endregion
 //#region host/runtime.ts
 /**
-* Resolve the API key env-var for the configured STT provider.
-*
-* Each STT provider uses its own env var (e.g. `ASSEMBLYAI_API_KEY`,
-* `DEEPGRAM_API_KEY`). We read the kind from the descriptor if it is one;
-* pre-resolved openers have no kind field so we fall back to AssemblyAI for
-* backward compatibility (openers supply their own key at open-time anyway).
+* Read the descriptor `kind` if present. Pre-resolved openers (test escape
+* hatch) have no `kind` field, so callers fall back to a default env var.
 */
+function descriptorKind(value) {
+	const kind = value?.kind;
+	return typeof kind === "string" ? kind : void 0;
+}
 function resolveSttApiKey(stt, env) {
-	if ((stt != null && "kind" in stt && typeof stt.kind === "string" ? stt.kind : void 0) === "deepgram") return resolveApiKey("DEEPGRAM_API_KEY", env);
+	if (descriptorKind(stt) === "deepgram") return resolveApiKey("DEEPGRAM_API_KEY", env);
 	return resolveApiKey("ASSEMBLYAI_API_KEY", env);
 }
-/**
-* Resolve the API key env-var for the configured TTS provider.
-*
-* Each TTS provider uses its own env var (e.g. `CARTESIA_API_KEY`,
-* `RIME_API_KEY`). We read the kind from the descriptor if it is one;
-* pre-resolved openers have no kind field so we fall back to Cartesia for
-* backward compatibility (openers supply their own key at open-time anyway).
-*/
 function resolveTtsApiKey(tts, env) {
-	if ((tts != null && "kind" in tts && typeof tts.kind === "string" ? tts.kind : void 0) === "rime") return resolveApiKey("RIME_API_KEY", env);
+	if (descriptorKind(tts) === "rime") return resolveApiKey("RIME_API_KEY", env);
 	return resolveApiKey("CARTESIA_API_KEY", env);
 }
 /**
@@ -3014,7 +2967,7 @@ function createLocalVector(slug) {
 * @public
 */
 function createRuntime(opts) {
-	const { agent, env, kv = createLocalKv(), vector, createWebSocket, logger = consoleLogger, s2sConfig = DEFAULT_S2S_CONFIG, sessionStartTimeoutMs, shutdownTimeoutMs = DEFAULT_SHUTDOWN_TIMEOUT_MS } = opts;
+	const { agent, env, kv = createLocalKv(), vector, createWebSocket, createOpenaiRealtimeWebSocket, logger = consoleLogger, s2sConfig = DEFAULT_S2S_CONFIG, sessionStartTimeoutMs, shutdownTimeoutMs = DEFAULT_SHUTDOWN_TIMEOUT_MS } = opts;
 	const mode = assertProviderTriple(opts.stt, opts.llm, opts.tts);
 	const slug = agent.name ?? "local";
 	const resolvedKv = agent.kv ? resolveKv(agent.kv, env, "") : kv;
@@ -3083,49 +3036,20 @@ function createRuntime(opts) {
 			});
 		};
 	}
-	const pipelineProviders = mode === "pipeline" ? {
+	let pipelineProviders = null;
+	if (mode === "pipeline" && opts.stt && opts.llm && opts.tts) pipelineProviders = {
 		stt: resolveSttIfDescriptor(opts.stt),
 		llm: resolveLlmIfDescriptor(opts.llm, env),
 		tts: resolveTtsIfDescriptor(opts.tts)
-	} : null;
-	function createSession(sessionOpts) {
-		sinkMap.set(sessionOpts.id, sessionOpts.client);
-		const isPipeline = Boolean(pipelineProviders);
-		const systemPrompt = buildSystemPrompt(agentConfig, {
-			hasTools: toolSchemas.length > 0 || (agentConfig.builtinTools?.length ?? 0) > 0,
-			voice: true,
-			toolGuidance
-		});
-		let core = null;
-		function bindCore() {
-			if (!core) throw new Error("SessionCore not yet created");
-			return core;
-		}
-		const callbacks = {
-			onReplyStarted: (replyId) => bindCore().onReplyStarted(replyId),
-			onReplyDone: () => bindCore().onReplyDone(),
-			onCancelled: () => bindCore().onCancelled(),
-			onAudioChunk: (bytes) => bindCore().onAudioChunk(bytes),
-			onAudioDone: () => bindCore().onAudioDone(),
-			onUserTranscript: (text) => bindCore().onUserTranscript(text),
-			onAgentTranscript: (text, interrupted) => bindCore().onAgentTranscript(text, interrupted),
-			onToolCall: isPipeline ? (id, name, args) => sessionOpts.client.event({
-				type: "tool_call",
-				toolCallId: id,
-				toolName: name,
-				args
-			}) : (id, name, args) => bindCore().onToolCall(id, name, args),
-			onError: (code, message) => bindCore().onError(code, message),
-			onSpeechStarted: () => bindCore().onSpeechStarted(),
-			onSpeechStopped: () => bindCore().onSpeechStopped()
-		};
-		let transport;
-		if (pipelineProviders) transport = createPipelineTransport({
+	};
+	function buildPipelineTransport(args) {
+		const { sessionOpts, systemPrompt, callbacks, providers } = args;
+		return createPipelineTransport({
 			sid: sessionOpts.id,
 			agent: sessionOpts.agent,
-			stt: pipelineProviders.stt,
-			llm: pipelineProviders.llm,
-			tts: pipelineProviders.tts,
+			stt: providers.stt,
+			llm: providers.llm,
+			tts: providers.tts,
 			callbacks,
 			sessionConfig: {
 				systemPrompt,
@@ -3145,7 +3069,29 @@ function createRuntime(opts) {
 			skipGreeting: sessionOpts.skipGreeting ?? false,
 			logger
 		});
-		else transport = createS2sTransport({
+	}
+	function buildOpenaiRealtimeTransport(args) {
+		const { sessionOpts, systemPrompt, callbacks } = args;
+		return createOpenaiRealtimeTransport({
+			apiKey: resolveApiKey("OPENAI_API_KEY", env),
+			options: agent.s2s?.options ?? {},
+			sessionConfig: {
+				systemPrompt,
+				...agentConfig.greeting !== void 0 ? { greeting: agentConfig.greeting } : {},
+				tools: toolSchemas
+			},
+			toolSchemas,
+			toolChoice: agentConfig.toolChoice ?? "auto",
+			callbacks,
+			sid: sessionOpts.id,
+			agent: sessionOpts.agent,
+			...createOpenaiRealtimeWebSocket ? { createWebSocket: createOpenaiRealtimeWebSocket } : {},
+			logger
+		});
+	}
+	function buildAssemblyS2sTransport(args) {
+		const { sessionOpts, systemPrompt, callbacks } = args;
+		return createS2sTransport({
 			apiKey: env.ASSEMBLYAI_API_KEY ?? "",
 			s2sConfig,
 			sessionConfig: {
@@ -3160,6 +3106,54 @@ function createRuntime(opts) {
 			...createWebSocket ? { createWebSocket } : {},
 			logger
 		});
+	}
+	function buildTransport(args) {
+		if (pipelineProviders) return buildPipelineTransport({
+			...args,
+			providers: pipelineProviders
+		});
+		if (agent.s2s !== void 0) {
+			const kind = descriptorKind(agent.s2s);
+			if (kind === "openai-realtime") return buildOpenaiRealtimeTransport(args);
+			throw new Error(`Unknown s2s provider kind: ${kind ?? "<missing>"}`);
+		}
+		return buildAssemblyS2sTransport(args);
+	}
+	function createSession(sessionOpts) {
+		sinkMap.set(sessionOpts.id, sessionOpts.client);
+		const isPipeline = Boolean(pipelineProviders);
+		const systemPrompt = buildSystemPrompt(agentConfig, {
+			hasTools: toolSchemas.length > 0 || (agentConfig.builtinTools?.length ?? 0) > 0,
+			voice: true,
+			toolGuidance
+		});
+		let core = null;
+		function bindCore() {
+			if (!core) throw new Error("SessionCore not yet created");
+			return core;
+		}
+		const transport = buildTransport({
+			sessionOpts,
+			systemPrompt,
+			callbacks: {
+				onReplyStarted: (replyId) => bindCore().onReplyStarted(replyId),
+				onReplyDone: () => bindCore().onReplyDone(),
+				onCancelled: () => bindCore().onCancelled(),
+				onAudioChunk: (bytes) => bindCore().onAudioChunk(bytes),
+				onAudioDone: () => bindCore().onAudioDone(),
+				onUserTranscript: (text) => bindCore().onUserTranscript(text),
+				onAgentTranscript: (text, interrupted) => bindCore().onAgentTranscript(text, interrupted),
+				onToolCall: isPipeline ? (id, name, args) => sessionOpts.client.event({
+					type: "tool_call",
+					toolCallId: id,
+					toolName: name,
+					args
+				}) : (id, name, args) => bindCore().onToolCall(id, name, args),
+				onError: (code, message) => bindCore().onError(code, message),
+				onSpeechStarted: () => bindCore().onSpeechStarted(),
+				onSpeechStopped: () => bindCore().onSpeechStopped()
+			}
+		});
 		core = createSessionCore({
 			id: sessionOpts.id,
 			agent: sessionOpts.agent,
@@ -3228,6 +3222,11 @@ function createRuntime(opts) {
 * **Internal module** — used by `aai-cli` dev server. Not a public API.
 * Import via `aai/host`.
 */
+const JSON_HEADERS = { "Content-Type": "application/json" };
+function sendJson(res, status, body) {
+	res.writeHead(status, JSON_HEADERS);
+	res.end(JSON.stringify(body));
+}
 async function serveStatic(dir, req, res) {
 	const url = req.url?.split("?")[0] ?? "/";
 	const filePath = path.join(dir, url === "/" ? "index.html" : url);
@@ -3247,66 +3246,59 @@ async function serveStatic(dir, req, res) {
 		return false;
 	}
 }
-function handleVectorPost(vector, req, res) {
+async function readBody(req) {
 	let body = "";
-	req.on("data", (chunk) => {
-		body += chunk;
-	});
-	req.on("end", async () => {
-		try {
-			const json = JSON.parse(body);
-			const parsed = VectorRequestSchema.safeParse(json);
-			if (!parsed.success) {
-				res.statusCode = 400;
-				res.end(JSON.stringify({ error: parsed.error.message }));
-				return;
-			}
-			const op = parsed.data;
-			let result;
-			switch (op.op) {
-				case "upsert":
-					await vector.upsert(op.id, op.text, op.metadata);
-					result = "OK";
-					break;
-				case "query":
-					result = await vector.query(op.text, {
-						...op.topK !== void 0 ? { topK: op.topK } : {},
-						...op.filter !== void 0 ? { filter: op.filter } : {}
-					});
-					break;
-				case "delete":
-					await vector.delete(op.ids);
-					result = "OK";
-					break;
-				default: break;
-			}
-			res.statusCode = 200;
-			res.end(JSON.stringify({ result }));
-		} catch (err) {
-			res.statusCode = 500;
-			res.end(JSON.stringify({ error: err instanceof Error ? err.message : String(err) }));
+	for await (const chunk of req) body += chunk;
+	return body;
+}
+async function handleVectorPost(vector, req, res) {
+	try {
+		const parsed = VectorRequestSchema.safeParse(JSON.parse(await readBody(req)));
+		if (!parsed.success) {
+			sendJson(res, 400, { error: parsed.error.message });
+			return;
 		}
-	});
+		const op = parsed.data;
+		let result;
+		switch (op.op) {
+			case "upsert":
+				await vector.upsert(op.id, op.text, op.metadata);
+				result = "OK";
+				break;
+			case "query":
+				result = await vector.query(op.text, {
+					...op.topK !== void 0 ? { topK: op.topK } : {},
+					...op.filter !== void 0 ? { filter: op.filter } : {}
+				});
+				break;
+			case "delete":
+				await vector.delete(op.ids);
+				result = "OK";
+				break;
+			default: return op;
+		}
+		sendJson(res, 200, { result });
+	} catch (err) {
+		sendJson(res, 500, { error: err instanceof Error ? err.message : String(err) });
+	}
 }
-function handleKvGet(kv, req, res) {
+async function handleKvGet(kv, req, res) {
 	const key = new URL(req.url ?? "/", "http://localhost").searchParams.get("key");
 	if (!key) {
-		res.writeHead(400, { "Content-Type": "application/json" });
-		res.end(JSON.stringify({ error: "Missing key query parameter" }));
+		sendJson(res, 400, { error: "Missing key query parameter" });
 		return;
 	}
-	kv.get(key).then((value) => {
+	try {
+		const value = await kv.get(key);
 		if (value === null) {
-			res.writeHead(404, { "Content-Type": "application/json" });
+			res.writeHead(404, JSON_HEADERS);
 			res.end("null");
-		} else {
-			res.writeHead(200, { "Content-Type": "application/json" });
-			res.end(JSON.stringify(value));
+			return;
 		}
-	}).catch(() => {
-		res.writeHead(500, { "Content-Type": "application/json" });
-		res.end(JSON.stringify({ error: "KV error" }));
-	});
+		sendJson(res, 200, value);
+	} catch {
+		sendJson(res, 500, { error: "KV error" });
+	}
 }
 /**
 * Create an HTTP + WebSocket server for an agent.
@@ -3317,8 +3309,17 @@ function createServer(options) {
 	const { runtime, clientHtml, clientDir, logger = consoleLogger, kv, vector } = options;
 	const name = options.name ?? "agent";
 	if (clientHtml && clientDir) throw new Error("clientHtml and clientDir are mutually exclusive");
-	const escapedName = escapeHtml(name);
-	const defaultHtml = clientHtml ?? `<!DOCTYPE html><html><body><h1>${escapedName}</h1><p>Agent server running.</p></body></html>`;
+	const defaultHtml = clientHtml ?? `<!DOCTYPE html><html><body><h1>${escapeHtml(name)}</h1><p>Agent server running.</p></body></html>`;
+	async function handleRequest(req, res, url, method) {
+		if (clientDir && await serveStatic(clientDir, req, res)) return;
+		if (method === "GET" && url === "/") {
+			res.writeHead(200, { "Content-Type": "text/html" });
+			res.end(defaultHtml);
+			return;
+		}
+		logger.error(`${method} ${url} 404`);
+		sendJson(res, 404, { error: "Not found" });
+	}
 	const httpServer = http.createServer((req, res) => {
 		const url = req.url?.split("?")[0] ?? "/";
 		const method = req.method ?? "GET";
@@ -3326,11 +3327,10 @@ function createServer(options) {
 		res.setHeader("X-Content-Type-Options", "nosniff");
 		res.setHeader("X-Frame-Options", "SAMEORIGIN");
 		if (method === "GET" && url === "/health") {
-			res.writeHead(200, { "Content-Type": "application/json" });
-			res.end(JSON.stringify({
+			sendJson(res, 200, {
 				status: "ok",
 				name
-			}));
+			});
 			return;
 		}
 		if (kv && method === "GET" && url === "/kv") {
@@ -3343,17 +3343,6 @@ function createServer(options) {
 		}
 		handleRequest(req, res, url, method);
 	});
-	async function handleRequest(req, res, url, method) {
-		if (clientDir && await serveStatic(clientDir, req, res)) return;
-		if (method === "GET" && url === "/") {
-			res.writeHead(200, { "Content-Type": "text/html" });
-			res.end(defaultHtml);
-			return;
-		}
-		logger.error(`${method} ${url} 404`);
-		res.writeHead(404, { "Content-Type": "application/json" });
-		res.end(JSON.stringify({ error: "Not found" }));
-	}
 	const wss = new WebSocketServer({
 		noServer: true,
 		maxPayload: MAX_WS_PAYLOAD_BYTES