@alexkroman1/aai-ui 1.9.2 → 1.10.0

package/dist/default-client/assets/{playback-processor-BtlzAH78.js → playback-processor-C5HVRVbu.js}

@@ -46,8 +46,11 @@ class PlaybackProcessor extends AudioWorkletProcessor {
   // End the current turn: notify the host and rearm for the next reply.
   // Must NOT return false from process() — a processor that stops is dead
   // for good, forcing a new node (and buffer) per reply.
-  stopTurn() {
-    this.port.postMessage({ event: 'stop' });
+  // \`reason\` ('interrupt' | 'done') tells the host which turn boundary this
+  // stop belongs to: interrupt-stops are dropped host-side (flush() already
+  // settled that turn), so they can never resolve a later turn's done() early.
+  stopTurn(reason) {
+    this.port.postMessage({ event: 'stop', reason });
     this.resetTurn();
   }
 
@@ -105,10 +108,14 @@ class PlaybackProcessor extends AudioWorkletProcessor {
   }
 
   process(inputs, outputs) {
+    // No output wired up yet — nothing to render this quantum. Throwing here
+    // would permanently kill the processor (the node is persistent per
+    // session), so guard like the capture processor does.
+    if (!outputs[0] || !outputs[0][0]) return true;
     const out = outputs[0][0];
     if (this.interrupted) {
       out.fill(0);
-      this.stopTurn();
+      this.stopTurn('interrupt');
       return true;
     }
 
@@ -139,7 +146,7 @@ class PlaybackProcessor extends AudioWorkletProcessor {
     // No data: output silence, end the turn only when done
     out.fill(0);
     if (this.isDone) {
-      this.stopTurn();
+      this.stopTurn('done');
     }
     return true;
   }

package/dist/default-client/index.html

@@ -6,8 +6,8 @@
     <title>aai</title>
     <link rel="icon" href="data:," />
     <style>html, body { background: #FBF8F2; margin: 0; }</style>
-    <script type="module" crossorigin src="./assets/index-Bf4ZTNcx.js"></script>
-    <link rel="stylesheet" crossorigin href="./assets/index-Bzlh9i7w.css">
+    <script type="module" crossorigin src="./assets/index-DtsWxxc_.js"></script>
+    <link rel="stylesheet" crossorigin href="./assets/index-B2bISVbm.css">
   </head>
   <body>
     <main id="app"></main>

package/dist/define-client.js

@@ -1,9 +1,9 @@
 import { SessionProvider, ThemeProvider } from "./context.js";
-import { n as ToolConfigContext } from "./tool-call-block-7f1GTG-P.js";
-import { t as ChatView } from "./chat-view-C1XbqDk0.js";
+import { n as ToolConfigContext } from "./tool-call-block-DIxpG8GM.js";
+import { t as ChatView } from "./chat-view-u3yBAlig.js";
 import { SidebarLayout } from "./components/sidebar-layout.js";
 import { StartScreen } from "./components/start-screen.js";
-import { t as createSessionCore } from "./session-core-D3NDaySY.js";
+import { t as createSessionCore } from "./session-core-Cfz7PPhN.js";
 import { createElement } from "react";
 import { jsx } from "react/jsx-runtime";
 import { flushSync } from "react-dom";

package/dist/hooks.js

@@ -1,5 +1,5 @@
 import { useSessionSelector } from "./context.js";
-import { n as tryParseJSON } from "./_utils-5cs73OrA.js";
+import { n as tryParseJSON } from "./_utils-CN1yVgYS.js";
 import { useEffect, useRef } from "react";
 //#region hooks.ts
 /** Index of the first item whose sequence number is above the watermark (tail scan from the end). */
@@ -51,13 +51,16 @@ function useToolCallEffect(status, args, fire) {
 		seq: 0,
 		fired: /* @__PURE__ */ new Set()
 	});
+	const mountedRef = useRef(false);
 	const callbackRef = useRef(callback);
 	callbackRef.current = callback;
 	const fireRef = useRef(fire);
 	fireRef.current = fire;
 	useEffect(() => {
+		const firstRun = !mountedRef.current;
+		mountedRef.current = true;
 		processToolCallTail(toolCalls, cursorRef.current, (tc) => status === "pending" || tc.status === status, (tc) => {
-			if (tc.status !== status) return;
+			if (tc.status !== status && firstRun) return;
 			if (filterName && tc.name !== filterName) return;
 			fireRef.current(callbackRef.current, tc, filterName !== null);
 		});

package/dist/index.d.ts

@@ -1,5 +1,6 @@
 export { Button } from "./components/button.tsx";
 export { ChatView } from "./components/chat-view.tsx";
+export { Controls } from "./components/controls.tsx";
 export { MessageList } from "./components/message-list.tsx";
 export { SidebarLayout } from "./components/sidebar-layout.tsx";
 export { StartScreen } from "./components/start-screen.tsx";

package/dist/index.js

@@ -1,12 +1,12 @@
 import { SessionProvider, ThemeProvider, useSession, useSessionSelector, useTheme } from "./context.js";
 import { Button } from "./components/button.js";
-import { i as UiUrlChip, n as ApiUrlChip, r as SessionUrlChips } from "./controls-BngrPbOC.js";
-import { n as ToolConfigContext } from "./tool-call-block-7f1GTG-P.js";
+import { i as UiUrlChip, n as ApiUrlChip, r as SessionUrlChips, t as Controls } from "./controls-B2EPUJDU.js";
+import { n as ToolConfigContext } from "./tool-call-block-DIxpG8GM.js";
 import { MessageList } from "./components/message-list.js";
-import { n as TextControls, t as ChatView } from "./chat-view-C1XbqDk0.js";
+import { n as TextControls, t as ChatView } from "./chat-view-u3yBAlig.js";
 import { SidebarLayout } from "./components/sidebar-layout.js";
 import { StartScreen } from "./components/start-screen.js";
-import { t as createSessionCore } from "./session-core-D3NDaySY.js";
+import { t as createSessionCore } from "./session-core-Cfz7PPhN.js";
 import { client } from "./define-client.js";
 import { useEvent, useToolCallStart, useToolResult } from "./hooks.js";
-export { ApiUrlChip, Button, ChatView, MessageList, SessionProvider, SessionUrlChips, SidebarLayout, StartScreen, TextControls, ThemeProvider, ToolConfigContext, UiUrlChip, client, createSessionCore, useEvent, useSession, useSessionSelector, useTheme, useToolCallStart, useToolResult };
+export { ApiUrlChip, Button, ChatView, Controls, MessageList, SessionProvider, SessionUrlChips, SidebarLayout, StartScreen, TextControls, ThemeProvider, ToolConfigContext, UiUrlChip, client, createSessionCore, useEvent, useSession, useSessionSelector, useTheme, useToolCallStart, useToolResult };

package/dist/{session-core-D3NDaySY.js → session-core-Cfz7PPhN.js}

@@ -1,7 +1,108 @@
 import "./types.js";
 import { DEFAULT_MAX_HISTORY, FILE_UPLOAD_CHUNK_BYTES, WS_OPEN, errorMessage, safeJsonParse } from "@alexkroman1/aai";
 import { ServerMessageSchema, lenientParse } from "@alexkroman1/aai/protocol";
+import ReconnectingWebSocket from "partysocket/ws";
 import { MAX_SYNC_AUDIO_SECONDS } from "@alexkroman1/aai/stt";
+//#region session-core-audio-setup.ts
+/**
+* Audio-path initialization for the voice session core.
+*
+* Split out of `session-core.ts`: this module owns the async
+* mic-permission → worklet-registration → `VoiceIO` bring-up (and its
+* staleness/failure handling), while `session-core.ts` owns the state store
+* and connection lifecycle.
+*/
+/**
+* Initialize audio capture and playback after the server sends a ready config.
+*
+* Lifecycle: dynamically import audio modules -> request microphone access ->
+* register AudioWorklet processors -> create a `VoiceIO` instance -> send
+* `audio_ready` to the server -> transition state to `"listening"`.
+*
+* Uses the connection `generation` counter to detect if `connect()` was called
+* (or a reconnect happened) while awaiting async operations; if so, the stale
+* VoiceIO is closed immediately to prevent it from being assigned to a newer
+* connection.
+*
+* `fatal` selects the failure mode: voice sessions (`config` handshake) can't
+* function without the mic, so failure there sets the error state and ends
+* the session; a text-only session's opt-in record button must not brick an
+* otherwise healthy session, so failure there is a banner (`error` set,
+* state kept) and the session stays interactive.
+*/
+async function initAudioCapture(conn, msg, deps, fatal) {
+	if (conn.audioSetupInFlight) return;
+	conn.audioSetupInFlight = true;
+	const gen = conn.generation;
+	const stale = () => conn.generation !== gen || !conn.ws || conn.ws.readyState !== WS_OPEN;
+	const reportAudioFailure = (message) => {
+		if (fatal) deps.updateState({
+			state: "error",
+			error: {
+				code: "audio",
+				message
+			},
+			running: false,
+			recording: false
+		});
+		else {
+			deps.cleanupAudio();
+			deps.updateState({
+				error: {
+					code: "audio",
+					message
+				},
+				recording: false
+			});
+		}
+	};
+	try {
+		const [{ createVoiceIO }, captureWorklet, playbackWorklet] = await Promise.all([
+			import("./audio.js"),
+			import("./worklets/capture-processor.js").then((m) => m.default),
+			import("./worklets/playback-processor.js").then((m) => m.default)
+		]);
+		const io = await createVoiceIO({
+			sttSampleRate: msg.sampleRate,
+			ttsSampleRate: msg.ttsSampleRate,
+			captureWorkletSrc: captureWorklet,
+			playbackWorkletSrc: playbackWorklet,
+			onMicData: (pcm16) => {
+				try {
+					deps.sendAudio(new Uint8Array(pcm16));
+				} catch {
+					console.debug("[aai-ui] sendAudio dropped: connection closed");
+				}
+			},
+			onError: (err) => {
+				if (conn.generation !== gen) return;
+				reportAudioFailure(err.message);
+			}
+		});
+		if (stale()) {
+			io.close().catch(() => {});
+			return;
+		}
+		conn.voiceIO?.close().catch(() => {});
+		conn.voiceIO = io;
+		if (conn.preInitAudio.length > 0) {
+			for (const chunk of conn.preInitAudio) io.enqueue(chunk.buffer);
+			conn.preInitAudio = [];
+		}
+		deps.sendJson({ type: "audio_ready" });
+		deps.updateState({ recording: true });
+		if (conn.preInitDone) {
+			conn.preInitDone = false;
+			deps.settleWhenAudioDrained(io);
+		} else deps.updateState({ state: "listening" });
+	} catch (err) {
+		if (stale()) return;
+		reportAudioFailure(`Microphone access failed: ${errorMessage(err)}`);
+	} finally {
+		if (conn.generation === gen) conn.audioSetupInFlight = false;
+	}
+}
+//#endregion
 //#region session-core-messages.ts
 /**
 * Incoming-message handling for the voice session core.
@@ -48,7 +149,7 @@ function appendCapped(list, item, cap) {
 * dedup) that previously lived as closure locals in `createSessionCore`.
 */
 function createMessageHandlers(deps) {
-	const { getSnapshot, updateState, conn } = deps;
+	const { getSnapshot, updateState, conn, discardUpload, cleanupAudio } = deps;
 	/** Incremented on each turn boundary -- stale async callbacks compare against this. */
 	let handlerGeneration = 0;
 	/** Monotonically increasing counter for custom events -- used by useEvent to deduplicate. */
@@ -93,7 +194,7 @@ function createMessageHandlers(deps) {
 	function clearRecoveredError() {
 		const snap = getSnapshot();
 		if (snap.state === "error") updateState({
-			state: "disconnected",
+			state: "listening",
 			error: null
 		});
 		else if (snap.error !== null) updateState({ error: null });
@@ -104,14 +205,18 @@ function createMessageHandlers(deps) {
 			code: e.code,
 			message: e.message
 		} });
-		else updateState({
-			state: "error",
-			error: {
-				code: e.code,
-				message: e.message
-			},
-			running: false
-		});
+		else {
+			cleanupAudio();
+			updateState({
+				state: "error",
+				error: {
+					code: e.code,
+					message: e.message
+				},
+				running: false,
+				recording: false
+			});
+		}
 	}
 	/** Single entry point for all server->client session events. */
 	function handleEvent(e) {
@@ -169,6 +274,7 @@ function createMessageHandlers(deps) {
 				break;
 			case "reset":
 				handlerGeneration++;
+				discardUpload();
 				conn.voiceIO?.flush();
 				updateState({
 					...CLEARED_SESSION_STATE,
@@ -188,25 +294,31 @@ function createMessageHandlers(deps) {
 	/** Enqueue a PCM16 audio chunk for playback. Transitions state to `"speaking"` on the first chunk. */
 	function playAudioChunk(chunk) {
 		const snap = getSnapshot();
-		if (snap.state === "disconnected" && snap.error !== null) return;
+		if (snap.state === "error" || snap.state === "disconnected" && snap.error !== null) return;
 		if (snap.state !== "speaking") updateState({ state: "speaking" });
 		if (conn.voiceIO) conn.voiceIO.enqueue(chunk.buffer);
 		else if (conn.preInitAudio.length < MAX_PREINIT_AUDIO_CHUNKS) conn.preInitAudio.push(chunk);
 	}
+	/** See {@link MessageHandlers.settleWhenAudioDrained}. Captures
+	*  `handlerGeneration` so a completion (or failure) that lands after a turn
+	*  boundary is discarded instead of overwriting the newer turn's state. */
+	function settleWhenAudioDrained(io) {
+		const gen = handlerGeneration;
+		io.done().then(() => {
+			if (handlerGeneration !== gen) return;
+			updateState({ state: "listening" });
+		}).catch((err) => {
+			console.warn("Audio playback done failed:", err);
+		});
+	}
 	/**
 	* Signal that the server has finished sending audio for this turn.
 	* Waits for the audio queue to drain, then transitions state to `"listening"`.
 	* Uses the `handlerGeneration` counter to discard stale completions from interrupted turns.
 	*/
 	function playAudioDone() {
-		const gen = handlerGeneration;
 		const io = conn.voiceIO;
-		if (io) io.done().then(() => {
-			if (handlerGeneration !== gen) return;
-			updateState({ state: "listening" });
-		}).catch((err) => {
-			console.warn("Audio playback done failed:", err);
-		});
+		if (io) settleWhenAudioDrained(io);
 		else {
 			conn.preInitDone = true;
 			updateState({ state: "listening" });
@@ -244,7 +356,46 @@ function createMessageHandlers(deps) {
 		}
 		handleEvent(msg);
 	}
-	return { handleMessage };
+	return {
+		handleMessage,
+		settleWhenAudioDrained
+	};
+}
+//#endregion
+//#region session-core-reconnect.ts
+/**
+* Automatic reconnection for the browser session socket, built on
+* partysocket's `ReconnectingWebSocket`. Kept out of `session-core.ts` so
+* the state machine there reads as protocol logic, not socket plumbing.
+*/
+/**
+* Backoff for automatic reconnects after an unexpected close (partysocket):
+* exponential from 1s, capped at 15s, giving up after 10 attempts. Applies
+* only to the default socket implementation — an injected
+* `options.WebSocket` (tests) never reconnects on its own.
+*/
+const RECONNECT_OPTIONS = {
+	minReconnectionDelay: 1e3,
+	maxReconnectionDelay: 15e3,
+	reconnectionDelayGrowFactor: 2,
+	maxRetries: 10
+};
+/**
+* Open partysocket's reconnecting WebSocket. The URL is a *provider*,
+* re-evaluated on every attempt, so each retry picks up the current resume
+* URL rather than the one the session started with.
+*/
+function openReconnectingSocket(urlProvider) {
+	return new ReconnectingWebSocket(urlProvider, void 0, RECONNECT_OPTIONS);
+}
+/**
+* True while `socket` is a reconnecting socket that will retry after the
+* close event currently being handled. partysocket schedules the retry
+* *before* dispatching `close`, so `retryCount` already names the attempt
+* just scheduled — at `maxRetries` it has given up.
+*/
+function reconnectPending(socket) {
+	return socket instanceof ReconnectingWebSocket && socket.shouldReconnect && socket.retryCount < RECONNECT_OPTIONS.maxRetries;
 }
 //#endregion
 //#region session-core-upload.ts
@@ -325,6 +476,16 @@ function createUploadSender(deps) {
 	};
 }
 //#endregion
+//#region session-core-url.ts
+/** Build the session WebSocket URL from the platform URL and resume state. */
+function buildWsUrl(platformUrl, resume, sessionId) {
+	const wsUrl = new URL("websocket", platformUrl.endsWith("/") ? platformUrl : `${platformUrl}/`);
+	wsUrl.protocol = wsUrl.protocol === "https:" ? "wss:" : "ws:";
+	if (sessionId) wsUrl.searchParams.set("sessionId", sessionId);
+	else if (resume) wsUrl.searchParams.set("resume", "1");
+	return wsUrl;
+}
+//#endregion
 //#region session-core.ts
 /**
 * Framework-agnostic voice session core.
@@ -339,82 +500,6 @@ function createUploadSender(deps) {
 * No dependency on React, Preact, or any UI framework.
 */
 /**
-* Initialize audio capture and playback after the server sends a ready config.
-*
-* Lifecycle: dynamically import audio modules -> request microphone access ->
-* register AudioWorklet processors -> create a `VoiceIO` instance -> send
-* `audio_ready` to the server -> transition state to `"listening"`.
-*
-* Uses the connection `generation` counter to detect if `connect()` was called
-* while awaiting async operations; if so, the stale VoiceIO is closed immediately
-* to prevent it from being assigned to a newer connection.
-*
-* On failure (e.g. microphone permission denied, WebSocket closed mid-setup),
-* sets the error state and transitions to `"disconnected"`.
-*/
-async function initAudioCapture(conn, msg, deps) {
-	if (conn.audioSetupInFlight) return;
-	conn.audioSetupInFlight = true;
-	const gen = conn.generation;
-	try {
-		const [{ createVoiceIO }, captureWorklet, playbackWorklet] = await Promise.all([
-			import("./audio.js"),
-			import("./worklets/capture-processor.js").then((m) => m.default),
-			import("./worklets/playback-processor.js").then((m) => m.default)
-		]);
-		const io = await createVoiceIO({
-			sttSampleRate: msg.sampleRate,
-			ttsSampleRate: msg.ttsSampleRate,
-			captureWorkletSrc: captureWorklet,
-			playbackWorkletSrc: playbackWorklet,
-			onMicData: (pcm16) => {
-				try {
-					deps.sendAudio(new Uint8Array(pcm16));
-				} catch {
-					console.debug("[aai-ui] sendAudio dropped: connection closed");
-				}
-			}
-		});
-		if (conn.generation !== gen || !conn.ws || conn.ws.readyState !== WS_OPEN) {
-			io.close();
-			return;
-		}
-		conn.voiceIO = io;
-		if (conn.preInitAudio.length > 0) {
-			for (const chunk of conn.preInitAudio) io.enqueue(chunk.buffer);
-			conn.preInitAudio = [];
-		}
-		deps.sendJson({ type: "audio_ready" });
-		deps.updateState({ recording: true });
-		if (conn.preInitDone) {
-			conn.preInitDone = false;
-			io.done().then(() => {
-				if (conn.generation !== gen) return;
-				deps.updateState({ state: "listening" });
-			}).catch(() => deps.updateState({ state: "listening" }));
-		} else deps.updateState({ state: "listening" });
-	} catch (err) {
-		if (conn.generation !== gen || !conn.ws || conn.ws.readyState !== WS_OPEN) return;
-		deps.updateState({
-			state: "error",
-			error: {
-				code: "audio",
-				message: `Microphone access failed: ${errorMessage(err)}`
-			},
-			running: false
-		});
-	} finally {
-		conn.audioSetupInFlight = false;
-	}
-}
-function buildWsUrl(platformUrl, resume, sessionId) {
-	const wsUrl = new URL("websocket", platformUrl.endsWith("/") ? platformUrl : `${platformUrl}/`);
-	wsUrl.protocol = wsUrl.protocol === "https:" ? "wss:" : "ws:";
-	if (sessionId) wsUrl.searchParams.set("sessionId", sessionId);
-	else if (resume) wsUrl.searchParams.set("resume", "1");
-	return wsUrl;
-}
-/**
 * Create a framework-agnostic voice session core that connects to an AAI
 * server via WebSocket.
 *
@@ -427,7 +512,6 @@ function buildWsUrl(platformUrl, resume, sessionId) {
 * @public
 */
 function createSessionCore(options) {
-	const WS = options.WebSocket ?? WebSocket;
 	let currentSnapshot = {
 		...CLEARED_SESSION_STATE,
 		state: "disconnected",
@@ -483,7 +567,7 @@ function createSessionCore(options) {
 	function cleanupAudio() {
 		upload.discard();
 		conn.audioSetupInFlight = false;
-		conn.voiceIO?.close();
+		conn.voiceIO?.close().catch(() => {});
 		conn.voiceIO = null;
 		conn.preInitAudio = [];
 		conn.preInitDone = false;
@@ -499,21 +583,25 @@ function createSessionCore(options) {
 		if (conn.ws.bufferedAmount > 65536) return;
 		conn.ws.send(bytes);
 	}
-	const audioDeps = {
-		sendJson,
-		sendAudio,
-		updateState
-	};
 	const upload = createUploadSender({
 		conn,
 		getSnapshot,
 		sendJson
 	});
-	const { handleMessage } = createMessageHandlers({
+	const { handleMessage, settleWhenAudioDrained } = createMessageHandlers({
 		getSnapshot,
 		updateState,
-		conn
+		conn,
+		discardUpload: upload.discard,
+		cleanupAudio
 	});
+	const audioDeps = {
+		sendJson,
+		sendAudio,
+		updateState,
+		settleWhenAudioDrained,
+		cleanupAudio
+	};
 	/** Abort the in-flight connection and release audio + WebSocket resources. */
 	function teardownConnection() {
 		connectionController?.abort();
@@ -534,7 +622,7 @@ function createSessionCore(options) {
 		};
 		const audioOut = config.audioOut !== false;
 		updateState({ audioOut });
-		if (audioOut) initAudioCapture(conn, config, audioDeps);
+		if (audioOut) initAudioCapture(conn, config, audioDeps, true);
 		else {
 			sendJson({ type: "audio_ready" });
 			updateState({ state: "listening" });
@@ -547,7 +635,27 @@ function createSessionCore(options) {
 			}))
 		});
 	}
+	/**
+	* The WebSocket URL for the *next* connection attempt. Evaluated per
+	* attempt (partysocket takes it as a URL provider), so once the first
+	* `config` arrives, every reconnect — automatic or explicit — carries
+	* `resume=1` and the session resumes instead of starting over.
+	*/
+	function currentWsUrl() {
+		const resumeId = !hasConnected ? options.resumeSessionId : void 0;
+		return buildWsUrl(options.platformUrl, hasConnected, resumeId).toString();
+	}
+	/** Open a socket: an injected constructor as-is (tests), or partysocket's
+	*  reconnecting WebSocket — same interface, plus reconnect-on-close. */
+	function openSocket() {
+		if (options.WebSocket) return new options.WebSocket(currentWsUrl());
+		return openReconnectingSocket(currentWsUrl);
+	}
 	function connect(opts) {
+		if (opts?.signal?.aborted) {
+			disconnect();
+			return;
+		}
 		updateState({
 			state: "connecting",
 			error: null
@@ -558,11 +666,10 @@ function createSessionCore(options) {
 		connectionController = controller;
 		const { signal: sig } = controller;
 		if (opts?.signal) opts.signal.addEventListener("abort", () => disconnect(), { signal: sig });
-		const resumeId = !hasConnected ? options.resumeSessionId : void 0;
-		const wsUrl = buildWsUrl(options.platformUrl, hasConnected, resumeId);
-		const socket = new WS(wsUrl.toString());
+		const socket = openSocket();
 		socket.binaryType = "arraybuffer";
 		conn.ws = socket;
+		let socketErrored = false;
 		socket.addEventListener("open", () => {
 			updateState({ state: "ready" });
 		}, { signal: sig });
@@ -570,18 +677,47 @@ function createSessionCore(options) {
 			const config = handleMessage(event.data);
 			if (config) onServerConfig(config);
 		}, { signal: sig });
+		socket.addEventListener("error", () => {
+			socketErrored = true;
+		}, { signal: sig });
 		socket.addEventListener("close", () => {
 			if (sig.aborted) return;
-			controller.abort();
 			cleanupAudio();
-			updateState({
+			if (reconnectPending(socket)) {
+				conn.generation++;
+				socketErrored = false;
+				updateState({
+					state: "connecting",
+					recording: false
+				});
+				return;
+			}
+			controller.abort();
+			socket.close();
+			conn.ws = null;
+			if (socketErrored) updateState({
+				state: "error",
+				error: {
+					code: "connection",
+					message: "WebSocket connection error"
+				},
+				running: false,
+				recording: false
+			});
+			else if (currentSnapshot.state === "error") updateState({
+				running: false,
+				recording: false
+			});
+			else updateState({
 				state: "disconnected",
+				error: null,
 				running: false,
 				recording: false
 			});
 		}, { signal: sig });
 	}
 	function cancel() {
+		if (!conn.ws || conn.ws.readyState !== WS_OPEN) return;
 		conn.voiceIO?.flush();
 		updateState({ state: "listening" });
 		sendJson({ type: "cancel" });
@@ -595,6 +731,7 @@ function createSessionCore(options) {
 		}
 		resetState();
 		disconnect();
+		updateState({ running: true });
 		connect();
 	}
 	function disconnect() {
@@ -609,7 +746,7 @@ function createSessionCore(options) {
 		if (currentSnapshot.audioOut || currentSnapshot.recording || conn.audioSetupInFlight || upload.inFlight()) return;
 		const cfg = conn.readyConfig;
 		if (!(cfg && conn.ws) || conn.ws.readyState !== WS_OPEN) return;
-		initAudioCapture(conn, cfg, audioDeps);
+		initAudioCapture(conn, cfg, audioDeps, false);
 	}
 	function stopRecording() {
 		if (currentSnapshot.audioOut || !currentSnapshot.recording) return;

package/dist/session-core-audio-setup.d.ts

@@ -0,0 +1,36 @@
+import type { ClientMessage } from "@alexkroman1/aai/protocol";
+import type { VoiceIO } from "./audio.ts";
+import type { ConnState, SessionSnapshot } from "./session-core-types.ts";
+/** Dependencies `initAudioCapture` needs from the owning session core. */
+export type AudioSetupDeps = {
+    sendJson: (msg: ClientMessage) => void;
+    sendAudio: (bytes: Uint8Array) => void;
+    updateState: (partial: Partial<SessionSnapshot>) => void;
+    /** Turn-boundary-guarded drain from the message handlers — replays a
+     *  buffered `audio_done` without stomping a barge-in's state. */
+    settleWhenAudioDrained: (io: VoiceIO) => void;
+    /** Release the mic/VoiceIO (used when the audio path dies non-fatally). */
+    cleanupAudio: () => void;
+};
+/**
+ * Initialize audio capture and playback after the server sends a ready config.
+ *
+ * Lifecycle: dynamically import audio modules -> request microphone access ->
+ * register AudioWorklet processors -> create a `VoiceIO` instance -> send
+ * `audio_ready` to the server -> transition state to `"listening"`.
+ *
+ * Uses the connection `generation` counter to detect if `connect()` was called
+ * (or a reconnect happened) while awaiting async operations; if so, the stale
+ * VoiceIO is closed immediately to prevent it from being assigned to a newer
+ * connection.
+ *
+ * `fatal` selects the failure mode: voice sessions (`config` handshake) can't
+ * function without the mic, so failure there sets the error state and ends
+ * the session; a text-only session's opt-in record button must not brick an
+ * otherwise healthy session, so failure there is a banner (`error` set,
+ * state kept) and the session stays interactive.
+ */
+export declare function initAudioCapture(conn: ConnState, msg: {
+    sampleRate: number;
+    ttsSampleRate: number;
+}, deps: AudioSetupDeps, fatal: boolean): Promise<void>;