@alexkroman1/aai 1.5.0 → 1.6.0

package/dist/host/runtime-barrel.js

@@ -2,22 +2,24 @@ 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 { ClientMessageSchema, 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-3p3OJZPb.js";
-import { r as DEEPGRAM_KIND, t as ASSEMBLYAI_KIND } from "../assemblyai-C969QGi4.js";
+import { a as toAgentConfig, c as makeSttError, i as agentToolsToSchemas, l as makeTtsError, n as EMPTY_PARAMS, s as assertProviderTriple } from "../_internal-types-DFL07G3f.js";
+import { a as ASSEMBLYAI_KIND, r as ELEVENLABS_KIND, s as DEEPGRAM_KIND, t as SONIOX_KIND } from "../soniox-DCQ3GqJq.js";
 import { a as RIME_KIND, n as CARTESIA_KIND } from "../cartesia-BfQPOQ7Y.js";
-import { t as ANTHROPIC_KIND } from "../anthropic-CcLZygAr.js";
+import { a as MISTRAL_KIND, d as ANTHROPIC_KIND, l as GOOGLE_KIND, r as OPENAI_KIND, s as GROQ_KIND } from "../xai-jfQsxxPZ.js";
+import { createRequire } from "node:module";
 import { z } from "zod";
 import { convert } from "html-to-text";
 import vm from "node:vm";
 import pTimeout from "p-timeout";
 import { createStorage, prefixStorage } from "unstorage";
-import { createAnthropic } from "@ai-sdk/anthropic";
 import { AssemblyAI } from "assemblyai";
 import { createNanoEvents } from "nanoevents";
 import { DeepgramClient } from "@deepgram/sdk";
+import { ElevenLabsClient } from "@elevenlabs/elevenlabs-js";
+import { AudioFormat, CommitStrategy, RealtimeEvents } from "@elevenlabs/elevenlabs-js/wrapper/realtime/index.js";
+import WsWebSocket, { WebSocketServer } from "ws";
 import { randomUUID } from "node:crypto";
 import { Cartesia } from "@cartesia/cartesia-js";
-import WsWebSocket, { WebSocketServer } from "ws";
 import { jsonSchema, stepCountIs, streamText, tool } from "ai";
 import fs from "node:fs";
 import http from "node:http";
@@ -334,6 +336,7 @@ function resolveAllBuiltins(names, opts) {
 	for (const name of names) for (const [toolName, def] of resolveBuiltin(name, opts)) {
 		defs[toolName] = def;
 		schemas.push({
+			type: "function",
 			name: toolName,
 			description: def.description,
 			parameters: z.toJSONSchema(def.parameters ?? EMPTY_PARAMS)
@@ -564,6 +567,246 @@ function openDeepgram(opts = {}) {
 	};
 }
 //#endregion
+//#region host/providers/stt/elevenlabs.ts
+/**
+* ElevenLabs Scribe streaming STT opener (host-only).
+*
+* The user-facing descriptor factory (`elevenlabs(...)`) lives in
+* `sdk/providers/stt/elevenlabs.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: `"scribe_v2_realtime"`. Audio is sent as base64-encoded
+* PCM_16000; partial transcripts arrive on `transcript`, finals on
+* `committed_transcript`.
+*/
+/** Map a numeric sample rate to the SDK's `AudioFormat` enum. */
+function audioFormatFor(sampleRate) {
+	switch (sampleRate) {
+		case 8e3: return AudioFormat.PCM_8000;
+		case 16e3: return AudioFormat.PCM_16000;
+		case 22050: return AudioFormat.PCM_22050;
+		case 24e3: return AudioFormat.PCM_24000;
+		case 44100: return AudioFormat.PCM_44100;
+		case 48e3: return AudioFormat.PCM_48000;
+		default: throw makeSttError("stt_connect_failed", `ElevenLabs STT: unsupported sample rate ${sampleRate}. Supported: 8000, 16000, 22050, 24000, 44100, 48000.`);
+	}
+}
+/** Build an {@link SttOpener} from resolved ElevenLabs descriptor options. */
+function openElevenLabs(opts = {}) {
+	return {
+		name: "elevenlabs",
+		async open(openOpts) {
+			const apiKey = openOpts.apiKey || process.env.ELEVENLABS_API_KEY;
+			if (!apiKey) throw makeSttError("stt_auth_failed", "ElevenLabs STT: missing API key. Set ELEVENLABS_API_KEY in the agent env.");
+			const client = new ElevenLabsClient({ apiKey });
+			let connection;
+			try {
+				connection = await client.speechToText.realtime.connect({
+					modelId: opts.model ?? "scribe_v2_realtime",
+					audioFormat: audioFormatFor(openOpts.sampleRate),
+					sampleRate: openOpts.sampleRate,
+					commitStrategy: CommitStrategy.VAD,
+					...opts.languageCode ? { languageCode: opts.languageCode } : {}
+				});
+			} catch (cause) {
+				throw makeSttError("stt_connect_failed", `ElevenLabs STT: connect failed: ${cause instanceof Error ? cause.message : String(cause)}`);
+			}
+			const emitter = createNanoEvents();
+			let closed = false;
+			connection.on(RealtimeEvents.PARTIAL_TRANSCRIPT, (msg) => {
+				if (closed) return;
+				const text = msg.text ?? "";
+				if (text.length > 0) emitter.emit("partial", text);
+			});
+			connection.on(RealtimeEvents.COMMITTED_TRANSCRIPT, (msg) => {
+				if (closed) return;
+				const text = msg.text ?? "";
+				if (text.length > 0) emitter.emit("final", text);
+			});
+			connection.on(RealtimeEvents.ERROR, (payload) => {
+				if (closed) return;
+				const msg = payload instanceof Error ? payload.message : payload.error ?? `${payload.message_type}`;
+				emitter.emit("error", makeSttError("stt_stream_error", msg));
+			});
+			connection.on(RealtimeEvents.AUTH_ERROR, (msg) => {
+				if (closed) return;
+				emitter.emit("error", makeSttError("stt_auth_failed", msg.error));
+			});
+			const close = async () => {
+				if (closed) return;
+				closed = true;
+				try {
+					connection.close();
+				} catch {}
+			};
+			if (openOpts.signal.aborted) close();
+			else openOpts.signal.addEventListener("abort", () => void close(), { once: true });
+			return {
+				sendAudio(pcm) {
+					if (closed) return;
+					const bytes = Buffer.from(pcm.buffer, pcm.byteOffset, pcm.byteLength);
+					connection.send({ audioBase64: bytes.toString("base64") });
+				},
+				on(event, fn) {
+					return emitter.on(event, fn);
+				},
+				close
+			};
+		}
+	};
+}
+//#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) {
+		const text = tok.text ?? "";
+		if (text.length === 0) continue;
+		if (tok.is_final) appendFinal(text);
+		else nonFinal += text;
+	}
+	return nonFinal;
+}
+/** Resolve once the WebSocket opens; reject on the first error. */
+function waitForOpen$1(ws) {
+	return new Promise((resolve, reject) => {
+		const onOpen = () => {
+			ws.off("error", onErr);
+			resolve();
+		};
+		const onErr = (err) => {
+			ws.off("open", onOpen);
+			reject(err);
+		};
+		ws.once("open", onOpen);
+		ws.once("error", onErr);
+	});
+}
+/** Build the initial JSON config frame for a Soniox session. */
+function buildConfigFrame(apiKey, opts, sampleRate) {
+	const config = {
+		api_key: apiKey,
+		model: opts.model ?? "stt-rt-v3",
+		audio_format: "pcm_s16le",
+		sample_rate: sampleRate,
+		num_channels: 1
+	};
+	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());
+	} catch {
+		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"}`));
+		return;
+	}
+	if (!res.tokens || res.tokens.length === 0) return;
+	const nonFinal = consumeTokens(res.tokens, (text) => {
+		finalBuf.value += text;
+	});
+	if (finalBuf.value.length > 0 && (nonFinal.length > 0 || res.finished)) {
+		emitter.emit("final", finalBuf.value);
+		finalBuf.value = "";
+	}
+	if (nonFinal.length > 0) emitter.emit("partial", nonFinal);
+}
+/** Build an {@link SttOpener} from resolved Soniox descriptor options. */
+function openSoniox(opts = {}) {
+	return {
+		name: "soniox",
+		async open(openOpts) {
+			const apiKey = openOpts.apiKey || process.env.SONIOX_API_KEY;
+			if (!apiKey) throw makeSttError("stt_auth_failed", "Soniox STT: missing API key. Set SONIOX_API_KEY in the agent env.");
+			const ws = new WsWebSocket(SONIOX_WS_URL);
+			const emitter = createNanoEvents();
+			let closed = false;
+			const finalBuf = { value: "" };
+			try {
+				await waitForOpen$1(ws);
+			} catch (cause) {
+				throw makeSttError("stt_connect_failed", `Soniox STT: connect failed: ${cause instanceof Error ? cause.message : String(cause)}`);
+			}
+			ws.send(JSON.stringify(buildConfigFrame(apiKey, opts, openOpts.sampleRate)));
+			ws.on("message", (raw) => {
+				if (closed) return;
+				const res = parseFrame(raw);
+				if (res) handleResponse(res, emitter, finalBuf);
+			});
+			ws.on("error", (err) => {
+				if (closed) return;
+				emitter.emit("error", makeSttError("stt_stream_error", err.message ?? String(err)));
+			});
+			ws.on("close", (code) => {
+				if (closed) return;
+				if (code !== 1e3) emitter.emit("error", makeSttError("stt_stream_error", `socket closed ${code}`));
+			});
+			const close = async () => {
+				if (closed) return;
+				closed = true;
+				if (finalBuf.value.length > 0) {
+					emitter.emit("final", finalBuf.value);
+					finalBuf.value = "";
+				}
+				try {
+					ws.close();
+				} catch {}
+			};
+			if (openOpts.signal.aborted) close();
+			else openOpts.signal.addEventListener("abort", () => void close(), { once: true });
+			return {
+				sendAudio(pcm) {
+					if (closed || ws.readyState !== WsWebSocket.OPEN) return;
+					ws.send(new Uint8Array(pcm.buffer, pcm.byteOffset, pcm.byteLength), { binary: true });
+				},
+				on(event, fn) {
+					return emitter.on(event, fn);
+				},
+				close
+			};
+		}
+	};
+}
+//#endregion
 //#region host/providers/tts/cartesia.ts
 /**
 * Cartesia TTS opener (host-only).
@@ -962,7 +1205,14 @@ function openRime(opts) {
 * The guest sandbox never imports these functions, which is how the agent
 * bundle stays free of `@ai-sdk/anthropic` / `assemblyai` /
 * `@cartesia/cartesia-js`.
+*
+* `@ai-sdk/*` packages are loaded via `createRequire` lazily so self-hosted
+* users only need to install the providers they actually reference. A
+* missing package is reported as a friendly "package not installed" error
+* at first session start, not as a module-load failure when the host
+* package itself is imported.
 */
+const requireFromHere = createRequire(import.meta.url);
 /**
 * Look up a provider API key: agent env first (set via `aai secret put` or
 * `.env`), then the host's `process.env` as a fallback for self-hosted mode.
@@ -976,7 +1226,9 @@ function resolveStt(descriptor) {
 	switch (descriptor.kind) {
 		case ASSEMBLYAI_KIND: return openAssemblyAI(descriptor.options);
 		case DEEPGRAM_KIND: return openDeepgram(descriptor.options);
-		default: throw new Error(`Unknown STT provider kind: "${descriptor.kind}". Supported: ${ASSEMBLYAI_KIND}, ${DEEPGRAM_KIND}.`);
+		case ELEVENLABS_KIND: return openElevenLabs(descriptor.options);
+		case SONIOX_KIND: return openSoniox(descriptor.options);
+		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. */
@@ -991,24 +1243,73 @@ function resolveTts(descriptor) {
 * Resolve an {@link LlmProvider} descriptor into a Vercel AI SDK
 * {@link LanguageModel}.
 *
-* The API key is pulled from the agent's env (e.g. `ANTHROPIC_API_KEY`).
+* The API key is pulled from the agent's env (e.g. `OPENAI_API_KEY`).
 * Missing keys throw here — the pipeline session would fail on first
 * `streamText` call otherwise, and the error is clearer at construction.
 */
 function resolveLlm(descriptor, env) {
 	switch (descriptor.kind) {
 		case ANTHROPIC_KIND: {
-			const options = descriptor.options;
-			const apiKey = resolveApiKey("ANTHROPIC_API_KEY", env);
-			if (!apiKey) throw new Error("Anthropic LLM: missing API key. Set ANTHROPIC_API_KEY in the agent env.");
+			const apiKey = requireKey(env, "ANTHROPIC_API_KEY", "Anthropic");
+			const { createAnthropic } = loadProviderPackage("@ai-sdk/anthropic", "Anthropic");
 			return createAnthropic({
 				apiKey,
 				baseURL: "https://api.anthropic.com/v1"
-			})(options.model);
+			})(descriptor.options.model);
+		}
+		case OPENAI_KIND: {
+			const apiKey = requireKey(env, "OPENAI_API_KEY", "OpenAI");
+			const { createOpenAI } = loadProviderPackage("@ai-sdk/openai", "OpenAI");
+			return createOpenAI({ apiKey })(descriptor.options.model);
+		}
+		case GOOGLE_KIND: {
+			const apiKey = requireKey(env, "GOOGLE_GENERATIVE_AI_API_KEY", "Google");
+			const { createGoogleGenerativeAI } = loadProviderPackage("@ai-sdk/google", "Google");
+			return createGoogleGenerativeAI({ apiKey })(descriptor.options.model);
 		}
-		default: throw new Error(`Unknown LLM provider kind: "${descriptor.kind}". Supported: ${ANTHROPIC_KIND}.`);
+		case MISTRAL_KIND: {
+			const apiKey = requireKey(env, "MISTRAL_API_KEY", "Mistral");
+			const { createMistral } = loadProviderPackage("@ai-sdk/mistral", "Mistral");
+			return createMistral({ apiKey })(descriptor.options.model);
+		}
+		case "xai": {
+			const apiKey = requireKey(env, "XAI_API_KEY", "xAI");
+			const { createXai } = loadProviderPackage("@ai-sdk/xai", "xAI");
+			return createXai({ apiKey })(descriptor.options.model);
+		}
+		case GROQ_KIND: {
+			const apiKey = requireKey(env, "GROQ_API_KEY", "Groq");
+			const { createGroq } = loadProviderPackage("@ai-sdk/groq", "Groq");
+			return createGroq({ apiKey })(descriptor.options.model);
+		}
+		default: throw new Error(`Unknown LLM provider kind: "${descriptor.kind}". Supported: ${ANTHROPIC_KIND}, ${OPENAI_KIND}, ${GOOGLE_KIND}, ${MISTRAL_KIND}, xai, ${GROQ_KIND}.`);
 	}
 }
+function requireKey(env, name, label) {
+	const key = resolveApiKey(name, env);
+	if (!key) throw new Error(`${label} LLM: missing API key. Set ${name} in the agent env.`);
+	return key;
+}
+/**
+* Synchronously load an optional `@ai-sdk/*` package via `createRequire`.
+* Throws a friendly install-hint error if the package isn't installed,
+* so users see "Run `pnpm add @ai-sdk/openai`" rather than a cryptic
+* Node module-resolution stack trace.
+*/
+function loadProviderPackage(name, label) {
+	try {
+		return requireFromHere(name);
+	} catch (err) {
+		if (isModuleNotFound(err, name)) throw new Error(`${label} LLM: package \`${name}\` is not installed. Run \`pnpm add ${name}\`.`, { cause: err });
+		throw err;
+	}
+}
+function isModuleNotFound(err, name) {
+	if (!(err instanceof Error)) return false;
+	const code = err.code;
+	if (code !== "MODULE_NOT_FOUND" && code !== "ERR_MODULE_NOT_FOUND") return false;
+	return err.message.includes(name);
+}
 //#endregion
 //#region host/runtime-config.ts
 /**
@@ -1492,9 +1793,10 @@ function createPipelineTransport(opts) {
 				stopWhen: stepCountIs(maxSteps),
 				abortSignal: ctl.signal
 			});
+			const handlePart = makeStreamPartHandler(onDelta);
 			for await (const part of result.fullStream) {
 				if (ctl.signal.aborted) break;
-				handleStreamPart(part, ctl, onDelta);
+				handlePart(part);
 			}
 		} catch (err) {
 			if (!ctl.signal.aborted) {
@@ -1507,31 +1809,54 @@ function createPipelineTransport(opts) {
 			}
 		}
 	}
-	function handleStreamPart(part, _ctl, onDelta) {
-		switch (part.type) {
-			case "text-delta": {
-				const delta = part.text ?? "";
-				if (delta.length === 0) return;
-				onDelta(delta);
-				ttsSession?.sendText(delta);
-				return;
-			}
-			case "tool-call": {
-				const input = part.input ?? {};
-				callbacks.onToolCall(part.toolCallId ?? "", part.toolName ?? "", input);
-				return;
-			}
-			case "error": {
-				const msg = errorMessage(part.error);
-				log.error("LLM stream error", {
-					message: msg,
-					sid: opts.sid
-				});
-				emitError("llm", msg);
-				return;
+	/**
+	* Stateful per-turn handler for `streamText` `fullStream` parts.
+	*
+	* Tracks text-segment boundaries so that consecutive segments — which the
+	* Vercel SDK emits across tool-call hops as `text-end` followed later by a
+	* fresh `text-start` — don't fuse into "...up.Got it" when concatenated for
+	* the transcript or streamed to TTS. When a boundary is crossed and neither
+	* side carries whitespace, a single space is injected into both streams.
+	*/
+	function makeStreamPartHandler(onDelta) {
+		let pendingSeparator = false;
+		let lastChar = "";
+		function emitText(delta) {
+			if (delta.length === 0) return;
+			let out = delta;
+			if (pendingSeparator) {
+				pendingSeparator = false;
+				if (!(lastChar === "" || /\s/.test(lastChar) || /^\s/.test(out))) out = ` ${out}`;
 			}
-			default: return;
+			lastChar = out.slice(-1);
+			onDelta(out);
+			ttsSession?.sendText(out);
 		}
+		return function handlePart(part) {
+			switch (part.type) {
+				case "text-delta":
+					emitText(part.text ?? "");
+					return;
+				case "text-end":
+					pendingSeparator = true;
+					return;
+				case "tool-call": {
+					const input = part.input ?? {};
+					callbacks.onToolCall(part.toolCallId ?? "", part.toolName ?? "", input);
+					return;
+				}
+				case "error": {
+					const msg = errorMessage(part.error);
+					log.error("LLM stream error", {
+						message: msg,
+						sid: opts.sid
+					});
+					emitError("llm", msg);
+					return;
+				}
+				default: return;
+			}
+		};
 	}
 	/**
 	* Flush TTS and wait for drain. Resolves on:
@@ -1969,11 +2294,182 @@ function connectS2s(opts) {
 //#region host/transports/s2s-transport.ts
 /** @internal Exposed for testing — allows spying on connectS2s in unit tests. */
 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.
+*/
+const TRANSIENT_CLOSE_CODES = new Set([
+	1005,
+	1006,
+	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) => {
+				providerSessionId = id;
+				sessionReadyAt = Date.now();
+				if (reconnecting) {
+					reconnecting = false;
+					reconnectInFlight = false;
+					log.info("S2S resumed", {
+						sid: opts.sid,
+						sessionId: id
+					});
+				}
+				opts.callbacks.onSessionReady?.(id);
+			},
+			onReplyStarted: (replyId) => {
+				currentReplyId = replyId;
+				opts.callbacks.onReplyStarted(replyId);
+			},
+			onReplyDone: () => {
+				currentReplyId = null;
+				opts.callbacks.onReplyDone();
+			},
+			onCancelled: () => {
+				currentReplyId = null;
+				opts.callbacks.onCancelled();
+			},
+			onAudio: (bytes) => opts.callbacks.onAudioChunk(bytes),
+			onUserTranscript: opts.callbacks.onUserTranscript,
+			onAgentTranscript: opts.callbacks.onAgentTranscript,
+			onToolCall: opts.callbacks.onToolCall,
+			onSpeechStarted: opts.callbacks.onSpeechStarted,
+			onSpeechStopped: opts.callbacks.onSpeechStopped,
+			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;
+				}
+				log.info("S2S session expired", { sid: opts.sid });
+				handle?.close();
+			},
+			onError: (err) => opts.callbacks.onError("internal", err.message),
+			onClose: (code, reason) => handleClose(code, reason)
+		};
+	}
+	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;
+	}
+	function emitFatalClose(code, reason, wasReconnecting) {
+		if (wasReconnecting) {
+			reconnecting = false;
+			reconnectInFlight = false;
+			opts.callbacks.onError("connection", `S2S resume failed (code=${code})`);
+			return;
+		}
+		if (currentReplyId !== null) {
+			log.warn("S2S closed with active reply", {
+				sid: opts.sid,
+				agent: opts.agent,
+				activeReplyId: currentReplyId,
+				code,
+				reason
+			});
+			opts.callbacks.onError("connection", `S2S closed mid-reply (code=${code})`);
+			return;
+		}
+		log.info("S2S closed", {
+			code,
+			reason
+		});
+	}
+	function startResume(prevId, code, reason) {
+		reconnectInFlight = true;
+		reconnecting = true;
+		log.warn("S2S unexpected close — attempting resume", {
+			sid: opts.sid,
+			agent: opts.agent,
+			code,
+			reason,
+			prevSessionId: prevId
+		});
+		if (currentReplyId !== null) {
+			currentReplyId = null;
+			opts.callbacks.onCancelled();
+		}
+		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,
+				error: msg
+			});
+			opts.callbacks.onError("connection", `S2S resume failed: ${msg}`);
+		});
+	}
+	function handleClose(code, reason) {
+		if (closing) {
+			log.info("S2S closed", {
+				code,
+				reason
+			});
+			return;
+		}
+		const wasReconnecting = reconnecting;
+		if (!canResumeAfter(code)) {
+			emitFatalClose(code, reason, wasReconnecting);
+			return;
+		}
+		const prevId = providerSessionId;
+		if (prevId === null) return;
+		startResume(prevId, code, reason);
+	}
+	async function resume(prevSessionId) {
+		const newHandle = await _internals.connectS2s({
+			apiKey: opts.apiKey,
+			config: opts.s2sConfig,
+			createWebSocket: createWs,
+			logger: log,
+			...opts.sid !== void 0 ? { sid: opts.sid } : {},
+			callbacks: buildCallbacks()
+		});
+		if (closing) {
+			newHandle.close();
+			return;
+		}
+		handle = newHandle;
+		newHandle.resumeSession(prevSessionId);
+	}
 	async function start() {
 		handle = await _internals.connectS2s({
 			apiKey: opts.apiKey,
@@ -1981,51 +2477,12 @@ function createS2sTransport(opts) {
 			createWebSocket: createWs,
 			logger: log,
 			sid: opts.sid,
-			callbacks: {
-				onSessionReady: (providerSessionId) => opts.callbacks.onSessionReady?.(providerSessionId),
-				onReplyStarted: (replyId) => {
-					currentReplyId = replyId;
-					opts.callbacks.onReplyStarted(replyId);
-				},
-				onReplyDone: () => {
-					currentReplyId = null;
-					opts.callbacks.onReplyDone();
-				},
-				onCancelled: () => {
-					currentReplyId = null;
-					opts.callbacks.onCancelled();
-				},
-				onAudio: (bytes) => opts.callbacks.onAudioChunk(bytes),
-				onUserTranscript: opts.callbacks.onUserTranscript,
-				onAgentTranscript: opts.callbacks.onAgentTranscript,
-				onToolCall: opts.callbacks.onToolCall,
-				onSpeechStarted: opts.callbacks.onSpeechStarted,
-				onSpeechStopped: opts.callbacks.onSpeechStopped,
-				onSessionExpired: () => {
-					log.info("S2S session expired", { sid: opts.sid });
-					handle?.close();
-				},
-				onError: (err) => opts.callbacks.onError("internal", err.message),
-				onClose: (code, reason) => {
-					if (currentReplyId !== null) {
-						log.warn("S2S closed with active reply", {
-							sid: opts.sid,
-							agent: opts.agent,
-							activeReplyId: currentReplyId,
-							code,
-							reason
-						});
-						opts.callbacks.onError("connection", `S2S closed mid-reply (code=${code})`);
-					} else log.info("S2S closed", {
-						code,
-						reason
-					});
-				}
-			}
+			callbacks: buildCallbacks()
 		});
 		handle.updateSession(opts.sessionConfig);
 	}
 	async function stop() {
+		closing = true;
 		handle?.close();
 		handle = null;
 	}