@alexkroman1/aai-ui 1.16.0 → 3.0.0

package/dist/_module-url-C_4gRVL0.js

@@ -0,0 +1,15 @@
+//#region worklets/_module-url.ts
+/**
+* Blob-URL module for an inlined AudioWorklet processor source.
+*
+* A blob URL rather than a data URI because the agent page's CSP allows
+* `script-src blob:` but not `data:` — a data-URI module fails `addModule`
+* with the opaque "Unable to load a worklet's module". Every inline worklet
+* in this package must load through this helper so that constraint lives in
+* one place.
+*/
+function workletModuleUrl(source) {
+	return URL.createObjectURL(new Blob([source], { type: "application/javascript" }));
+}
+//#endregion
+export { workletModuleUrl as t };

package/dist/audio.d.ts

@@ -1,12 +1,35 @@
 /**
- * Decode an audio file (any container/codec the browser can decode) and
- * resample it to mono PCM16 at `targetRate` — the format the server's STT
- * side expects on the wire. Returns the raw clip; any endpointing padding
- * is the caller's concern (the one-shot upload path needs none).
+ * Clamp-and-convert Float32 samples to PCM16. The one main-thread home of the
+ * asymmetric-rounding convention (negative × 0x8000, positive × 0x7fff) —
+ * the capture worklet's `accumulate` embeds the same math, which cannot
+ * import it (worklet source is a string).
  *
- * @throws If the browser cannot decode the payload.
+ * @public
  */
-export declare function decodeAudioToPcm16(data: ArrayBuffer, targetRate: number): Promise<Int16Array>;
+export declare function floatToPcm16(samples: Float32Array): Int16Array;
+/**
+ * How much of one turn's playback was covered by concealment rather than
+ * received audio — the playback worklet's underrun report, in the shape
+ * WebRTC's `inbound-rtp` audio stats use, so the numbers mean the same thing
+ * here as in a `getStats()` dump.
+ *
+ * A turn with `concealmentEvents: 0` never needed its jitter buffer; a turn
+ * with a high `silentConcealedSamples` share starved for longer than
+ * concealment can plausibly cover, which is a bandwidth problem rather than a
+ * buffer-tuning one.
+ *
+ * @public
+ */
+export type PlaybackStats = {
+    /** Samples emitted to cover a gap, including the silent ones. */
+    concealedSamples: number;
+    /** The subset of {@link PlaybackStats.concealedSamples} that were silence. */
+    silentConcealedSamples: number;
+    /** Distinct underrun episodes, however many render quanta each spanned. */
+    concealmentEvents: number;
+    /** Episodes that lasted long enough to decay to silence. */
+    silentConcealmentEvents: number;
+};
 /** Configuration for creating a {@link VoiceIO} instance. */
 export type VoiceIOOptions = {
     /** Sample rate in Hz expected by the STT engine (e.g. 16000). */
@@ -25,13 +48,24 @@ export type VoiceIOOptions = {
      * transition out of listening/speaking instead of looking healthy forever.
      */
     onError?: ((err: Error) => void) | undefined;
+    /**
+     * Called at the end of any turn whose playback had to conceal a gap. Never
+     * called for a clean turn, so it can be wired straight to a warning.
+     */
+    onPlaybackStats?: ((stats: PlaybackStats) => void) | undefined;
+    /**
+     * Called once if the microphone delivers nothing but digital silence for
+     * the first {@link MIC_SILENCE_PROBE_MS} of capture — a muted or wrong input
+     * device, which otherwise looks exactly like a user who hasn't spoken.
+     */
+    onMicSilent?: (() => void) | undefined;
 };
 /**
  * Audio I/O interface for voice capture and playback.
  *
- * Manages microphone capture via an AudioWorklet, resampling to the STT
- * sample rate, and TTS audio playback through a second AudioWorklet. Implements
- * {@link AsyncDisposable} for resource cleanup.
+ * Manages microphone capture via an AudioWorklet and TTS audio playback
+ * through a second AudioWorklet. Implements {@link AsyncDisposable} for
+ * resource cleanup.
  */
 export type VoiceIO = AsyncDisposable & {
     /** Enqueue a PCM16 audio buffer for playback through the TTS pipeline. */
@@ -44,12 +78,52 @@ export type VoiceIO = AsyncDisposable & {
     /** Release all audio resources (microphone, AudioContext, worklets). */
     close(): Promise<void>;
 };
+/**
+ * Throw unless the browser honored a requested context sample rate. The
+ * requested rates are never advisory: captured audio is tagged with the
+ * requested rate on the wire, so a context running at some other rate ships
+ * audio that only sounds like speech to the wrong decoder. Every capture
+ * path must call this after context creation.
+ */
+export declare function assertGranted(granted: number, requested: number, side: string): void;
+/**
+ * Release a microphone that was (or later gets) granted while another init
+ * step failed; if `getUserMedia` itself rejected, this is a no-op. Without
+ * it, a mic granted after a failed init keeps the browser's recording
+ * indicator lit with no way to turn it off.
+ */
+export declare function releaseStreamOnFailure(streamPromise: Promise<MediaStream>): void;
+/** Handle to one capture worklet node (`worklets/capture-processor.ts`). */
+export type CaptureNode = {
+    node: AudioWorkletNode;
+    /** Begin accumulating — the worklet gates capture on its start/stop protocol. */
+    start(): void;
+    /**
+     * Stop accumulating and wait (bounded by {@link CAPTURE_STOP_ACK_TIMEOUT_MS})
+     * for the 'stopped' ack that follows the worklet's final flush, so the tail
+     * of speech reaches `onChunk` before the node is torn down.
+     */
+    stop(): Promise<void>;
+};
+/**
+ * Wire one capture worklet node: node construction, the chunk/silent/stopped
+ * port protocol, and the stop→ack handshake — one spelling for both the
+ * WebSocket mic and the push-to-talk recorder. No `processorOptions`: the
+ * worklet reads the context rate from its global scope (callers assert the
+ * granted rate first) and owns its own batching default — re-spelling
+ * defaults caller-side is drift.
+ */
+export declare function createCaptureNode(ctx: AudioContext, onChunk: (pcm16: ArrayBuffer) => void, onSilent?: () => void): CaptureNode;
 /**
  * Create a {@link VoiceIO} instance that captures microphone audio and
  * plays back TTS audio using the Web Audio API.
  *
- * The AudioContext runs at the TTS sample rate for playback fidelity.
- * Captured audio is resampled to the STT rate when the rates differ.
+ * Playback runs on a context at the TTS sample rate for fidelity, and capture
+ * on its own context at the STT rate so the *browser* performs the rate
+ * conversion with its band-limited resampler. The two collapse into one
+ * context when the rates match. A browser that declines either requested rate
+ * fails init rather than falling back to converting in the worklet, which
+ * would alias.
  *
  * @param opts - Voice I/O configuration options.
  * @returns A promise that resolves to a {@link VoiceIO} handle.

package/dist/audio.js

@@ -1,120 +1,156 @@
-import { MIC_BUFFER_SECONDS } from "./types.js";
+import { CAPTURE_STOP_ACK_TIMEOUT_MS, PLAYBACK_DONE_MAX_WAIT_MS, PLAYBACK_DONE_POLL_MS, VOICE_CAPTURE_CONSTRAINTS } from "./types.js";
 //#region audio.ts
-/** How often {@link VoiceIO.done} checks that the AudioContext is still rendering. */
-const DONE_POLL_INTERVAL_MS = 1e3;
 /**
-* Hard cap on waiting for playback to drain. The playback worklet buffers up
-* to 60s of audio, so the longest legitimate drain is just under that — a
-* wait past this means the processor died without reporting 'stop'.
-*/
-const DONE_MAX_WAIT_MS = 65e3;
-/**
-* Bounded wait for the capture worklet's 'stopped' ack during close(). The
-* ack follows the final flush, so waiting for it keeps the tail of speech
-* from being dropped; the timeout covers a dead worklet.
-*/
-const CAPTURE_STOP_ACK_TIMEOUT_MS = 250;
-/**
-* Decode an audio file (any container/codec the browser can decode) and
-* resample it to mono PCM16 at `targetRate` — the format the server's STT
-* side expects on the wire. Returns the raw clip; any endpointing padding
-* is the caller's concern (the one-shot upload path needs none).
+* Clamp-and-convert Float32 samples to PCM16. The one main-thread home of the
+* asymmetric-rounding convention (negative × 0x8000, positive × 0x7fff) —
+* the capture worklet's `accumulate` embeds the same math, which cannot
+* import it (worklet source is a string).
 *
-* @throws If the browser cannot decode the payload.
+* @public
 */
-async function decodeAudioToPcm16(data, targetRate) {
-	const decoded = await new OfflineAudioContext(1, 1, targetRate).decodeAudioData(data);
-	const frames = Math.ceil(decoded.duration * targetRate);
-	const offline = new OfflineAudioContext(1, frames, targetRate);
-	const source = offline.createBufferSource();
-	source.buffer = decoded;
-	source.connect(offline.destination);
-	source.start();
-	const f32 = (await offline.startRendering()).getChannelData(0);
-	const pcm = new Int16Array(f32.length);
+function floatToPcm16(samples) {
+	const pcm = new Int16Array(samples.length);
 	let i = 0;
-	for (const sample of f32) {
+	for (const sample of samples) {
 		const s = Math.max(-1, Math.min(1, sample));
 		pcm[i++] = s < 0 ? s * 32768 : s * 32767;
 	}
 	return pcm;
 }
 /**
+* Throw unless the browser honored a requested context sample rate. The
+* requested rates are never advisory: captured audio is tagged with the
+* requested rate on the wire, so a context running at some other rate ships
+* audio that only sounds like speech to the wrong decoder. Every capture
+* path must call this after context creation.
+*/
+function assertGranted(granted, requested, side) {
+	if (granted === requested) return;
+	throw new Error(`Browser refused the ${side} sample rate: asked for ${requested} Hz, got ${granted} Hz`);
+}
+/**
+* Release a microphone that was (or later gets) granted while another init
+* step failed; if `getUserMedia` itself rejected, this is a no-op. Without
+* it, a mic granted after a failed init keeps the browser's recording
+* indicator lit with no way to turn it off.
+*/
+function releaseStreamOnFailure(streamPromise) {
+	streamPromise.then((s) => {
+		for (const t of s.getTracks()) t.stop();
+	}).catch(() => {});
+}
+/**
+* Wire one capture worklet node: node construction, the chunk/silent/stopped
+* port protocol, and the stop→ack handshake — one spelling for both the
+* WebSocket mic and the push-to-talk recorder. No `processorOptions`: the
+* worklet reads the context rate from its global scope (callers assert the
+* granted rate first) and owns its own batching default — re-spelling
+* defaults caller-side is drift.
+*/
+function createCaptureNode(ctx, onChunk, onSilent) {
+	const node = new AudioWorkletNode(ctx, "capture-processor", {
+		channelCount: 1,
+		channelCountMode: "explicit"
+	});
+	let onStopped = null;
+	node.port.onmessage = (e) => {
+		const d = e.data;
+		if (d.event === "chunk" && d.buffer) onChunk(d.buffer);
+		else if (d.event === "silent") onSilent?.();
+		else if (d.event === "stopped") {
+			onStopped?.();
+			onStopped = null;
+		}
+	};
+	return {
+		node,
+		start() {
+			node.port.postMessage({ event: "start" });
+		},
+		stop() {
+			return new Promise((resolve) => {
+				const cap = setTimeout(resolve, CAPTURE_STOP_ACK_TIMEOUT_MS);
+				onStopped = () => {
+					clearTimeout(cap);
+					resolve();
+				};
+				node.port.postMessage({ event: "stop" });
+			});
+		}
+	};
+}
+/**
 * Create a {@link VoiceIO} instance that captures microphone audio and
 * plays back TTS audio using the Web Audio API.
 *
-* The AudioContext runs at the TTS sample rate for playback fidelity.
-* Captured audio is resampled to the STT rate when the rates differ.
+* Playback runs on a context at the TTS sample rate for fidelity, and capture
+* on its own context at the STT rate so the *browser* performs the rate
+* conversion with its band-limited resampler. The two collapse into one
+* context when the rates match. A browser that declines either requested rate
+* fails init rather than falling back to converting in the worklet, which
+* would alias.
 *
 * @param opts - Voice I/O configuration options.
 * @returns A promise that resolves to a {@link VoiceIO} handle.
 * @throws If microphone access is denied or AudioWorklet registration fails.
 */
 async function createVoiceIO(opts) {
-	const { sttSampleRate, ttsSampleRate, captureWorkletSrc, playbackWorkletSrc, onMicData, onError } = opts;
-	const contextRate = ttsSampleRate;
+	const { sttSampleRate, ttsSampleRate, captureWorkletSrc, playbackWorkletSrc, onMicData, onError, onPlaybackStats, onMicSilent } = opts;
 	const ctx = new AudioContext({
-		sampleRate: contextRate,
+		sampleRate: ttsSampleRate,
 		latencyHint: "playback"
 	});
+	const sharesContext = sttSampleRate === ttsSampleRate;
+	const capCtx = sharesContext ? ctx : new AudioContext({
+		sampleRate: sttSampleRate,
+		latencyHint: "interactive"
+	});
+	async function closeContexts() {
+		const contexts = sharesContext ? [ctx] : [ctx, capCtx];
+		await Promise.all(contexts.map((c) => c.close().catch((err) => {
+			console.warn("AudioContext close failed:", err);
+		})));
+	}
 	const streamPromise = navigator.mediaDevices.getUserMedia({ audio: {
 		deviceId: { ideal: "default" },
-		echoCancellation: true,
-		noiseSuppression: true,
-		autoGainControl: true,
-		voiceIsolation: true
+		...VOICE_CAPTURE_CONSTRAINTS
 	} });
 	let stream;
 	try {
 		[stream] = await Promise.all([
 			streamPromise,
 			ctx.resume(),
-			ctx.audioWorklet.addModule(captureWorkletSrc),
+			capCtx.resume(),
+			capCtx.audioWorklet.addModule(captureWorkletSrc),
 			ctx.audioWorklet.addModule(playbackWorkletSrc)
 		]);
+		assertGranted(capCtx.sampleRate, sttSampleRate, "capture");
+		assertGranted(ctx.sampleRate, ttsSampleRate, "playback");
 	} catch (err) {
-		streamPromise.then((s) => {
-			for (const t of s.getTracks()) t.stop();
-		}).catch(() => {});
-		await ctx.close().catch((err) => {
-			console.warn("AudioContext close failed:", err);
-		});
+		releaseStreamOnFailure(streamPromise);
+		await closeContexts();
 		throw err;
 	}
-	const mic = ctx.createMediaStreamSource(stream);
-	const capNode = new AudioWorkletNode(ctx, "capture-processor", {
-		channelCount: 1,
-		channelCountMode: "explicit",
-		processorOptions: {
-			contextRate,
-			sttSampleRate,
-			bufferSeconds: MIC_BUFFER_SECONDS
-		}
-	});
-	mic.connect(capNode);
-	capNode.onprocessorerror = () => {
+	const mic = capCtx.createMediaStreamSource(stream);
+	const capture = createCaptureNode(capCtx, onMicData, onMicSilent);
+	mic.connect(capture.node);
+	capture.node.onprocessorerror = () => {
 		const err = /* @__PURE__ */ new Error("Audio capture worklet crashed");
 		console.error("[aai-ui]", err.message);
 		onError?.(err);
 	};
-	capNode.port.postMessage({ event: "start" });
-	let onCaptureStopped = null;
-	capNode.port.onmessage = (e) => {
-		if (e.data.event === "chunk") onMicData(e.data.buffer);
-		else if (e.data.event === "stopped") {
-			onCaptureStopped?.();
-			onCaptureStopped = null;
-		}
-	};
+	capture.start();
 	let playNode = null;
 	let onPlaybackStop = null;
 	const lifecycle = new AbortController();
 	function ensurePlayNode() {
 		if (playNode) return playNode;
-		const node = new AudioWorkletNode(ctx, "playback-processor", { processorOptions: { sampleRate: contextRate } });
+		const node = new AudioWorkletNode(ctx, "playback-processor");
 		node.connect(ctx.destination);
 		node.port.onmessage = (e) => {
 			if (e.data.event === "stop") {
+				const stats = e.data.stats;
+				if (stats && stats.concealedSamples > 0) onPlaybackStats?.(stats);
 				if (e.data.reason === "interrupt") return;
 				onPlaybackStop?.();
 				onPlaybackStop = null;
@@ -141,6 +177,7 @@ async function createVoiceIO(opts) {
 		},
 		done() {
 			if (!playNode) return Promise.resolve();
+			playNode.port.postMessage({ event: "done" });
 			if (ctx.state !== "running") return Promise.resolve();
 			return new Promise((resolve) => {
 				onPlaybackStop?.();
@@ -152,10 +189,9 @@ async function createVoiceIO(opts) {
 				};
 				const poll = setInterval(() => {
 					if (ctx.state !== "running") settle();
-				}, DONE_POLL_INTERVAL_MS);
-				const cap = setTimeout(settle, DONE_MAX_WAIT_MS);
+				}, PLAYBACK_DONE_POLL_MS);
+				const cap = setTimeout(settle, PLAYBACK_DONE_MAX_WAIT_MS);
 				onPlaybackStop = settle;
-				playNode?.port.postMessage({ event: "done" });
 			});
 		},
 		flush() {
@@ -167,19 +203,12 @@ async function createVoiceIO(opts) {
 		async close() {
 			if (lifecycle.signal.aborted) return;
 			lifecycle.abort();
-			await new Promise((resolve) => {
-				const cap = setTimeout(resolve, CAPTURE_STOP_ACK_TIMEOUT_MS);
-				onCaptureStopped = () => {
-					clearTimeout(cap);
-					resolve();
-				};
-				capNode.port.postMessage({ event: "stop" });
-			});
+			await capture.stop();
 			mic.disconnect();
-			capNode.disconnect();
+			capture.node.disconnect();
 			if (playNode) playNode.disconnect();
 			for (const t of stream.getTracks()) t.stop();
-			await ctx.close().catch(() => {});
+			await closeContexts();
 		},
 		async [Symbol.asyncDispose]() {
 			await io.close();
@@ -188,4 +217,4 @@ async function createVoiceIO(opts) {
 	return io;
 }
 //#endregion
-export { createVoiceIO, decodeAudioToPcm16 };
+export { assertGranted, createCaptureNode, createVoiceIO, floatToPcm16, releaseStreamOnFailure };

package/dist/chat-view-C1oJxsWz.js

@@ -0,0 +1,129 @@
+import { useSessionSelector, useTheme } from "./context.js";
+import { r as TEXT_FAINT, t as ERROR_COLOR } from "./_colors-DYX7XRTr.js";
+import { t as AaiLogo } from "./aai-logo-B8lDmsut.js";
+import { t as Eyebrow } from "./eyebrow-C6ZFuiz6.js";
+import { t as Controls } from "./controls-DV368uhb.js";
+import { MessageList } from "./components/message-list.js";
+import clsx from "clsx";
+import { jsx, jsxs } from "react/jsx-runtime";
+//#region components/console-shell.tsx
+/** @jsxImportSource react */
+/**
+* Indicator dot color per state, on the light refresh palette.
+*
+* @internal
+*/
+function stateColor(state, primary) {
+	switch (state) {
+		case "listening":
+		case "speaking":
+		case "ready": return primary;
+		case "thinking": return "#B98900";
+		case "error": return ERROR_COLOR;
+		default: return TEXT_FAINT;
+	}
+}
+/**
+* The design-system "console" chrome for the chat shell:
+* a 760px column on the cream page with a header
+* (logo + live-status eyebrow), an optional error banner, the main content
+* on a raised white card, and a footer row beneath it.
+*
+* Extracted so the two default surfaces stay visually identical by
+* construction — they used to be hand-copied down to the same `boxShadow`
+* literal, and drifted.
+*
+* @internal
+*/
+function ConsoleShell({ icon, title, state, pulsing, error, children, footer, className }) {
+	const theme = useTheme();
+	return /* @__PURE__ */ jsxs("div", {
+		className: clsx("flex flex-col h-screen w-full max-w-190 mx-auto box-border px-6 py-8 gap-5 font-aai text-sm", className),
+		style: {
+			background: theme.bg,
+			color: theme.text
+		},
+		children: [
+			/* @__PURE__ */ jsxs("div", {
+				className: "flex items-center justify-between shrink-0",
+				children: [/* @__PURE__ */ jsxs("div", {
+					className: "flex items-center gap-3 min-w-0",
+					children: [icon ?? /* @__PURE__ */ jsx(AaiLogo, { size: 22 }), title && /* @__PURE__ */ jsx("span", {
+						className: "font-aai-serif text-[22px] leading-[1.2] font-normal truncate",
+						style: { color: theme.text },
+						children: title
+					})]
+				}), /* @__PURE__ */ jsxs(Eyebrow, {
+					className: "shrink-0",
+					"data-state": state,
+					children: [/* @__PURE__ */ jsx("span", {
+						className: "w-[7px] h-[7px] rounded-full",
+						style: {
+							background: stateColor(state, theme.primary),
+							animation: pulsing ? "aai-pulse 1.6s ease-in-out infinite" : "none"
+						}
+					}), state]
+				})]
+			}),
+			error && /* @__PURE__ */ jsx("div", {
+				className: "px-3.5 py-2.5 rounded-aai border text-[13px] leading-[130%] shrink-0",
+				style: {
+					borderColor: "rgba(179,38,30,0.35)",
+					background: "rgba(179,38,30,0.06)",
+					color: "#B3261E"
+				},
+				children: error
+			}),
+			/* @__PURE__ */ jsx("div", {
+				className: "flex flex-col flex-1 min-h-0 border rounded-lg overflow-hidden",
+				style: {
+					background: theme.surface,
+					borderColor: theme.border,
+					boxShadow: "0 1px 3px 0 rgb(20 18 12 / 0.06)"
+				},
+				children
+			}),
+			footer
+		]
+	});
+}
+//#endregion
+//#region components/chat-view.tsx
+const PULSING_STATES = /* @__PURE__ */ new Set(["listening", "speaking"]);
+/**
+* The main chat interface for a voice agent session — the design-system
+* "voice agent console": a 760px column on the cream page with a header
+* (logo + live-status eyebrow), the conversation on a raised white card,
+* and the session controls beneath it.
+*
+* Must be rendered inside a {@link SessionProvider}.
+*
+* @example
+* ```tsx
+* <StartScreen icon="🍕" title="Pizza Palace">
+*   <ChatView />
+* </StartScreen>
+* ```
+*
+* @param icon - Optional element rendered in place of the logo in the header.
+* @param title - Optional title string for the header.
+* @param className - Additional CSS class names applied to the root element.
+*
+* @public
+*/
+function ChatView({ icon, title, className }) {
+	const state = useSessionSelector((s) => s.state);
+	const error = useSessionSelector((s) => s.error);
+	return /* @__PURE__ */ jsx(ConsoleShell, {
+		icon,
+		title,
+		state,
+		pulsing: PULSING_STATES.has(state),
+		error: error?.message,
+		className,
+		footer: /* @__PURE__ */ jsx(Controls, {}),
+		children: /* @__PURE__ */ jsx(MessageList, {})
+	});
+}
+//#endregion
+export { ChatView as t };

package/dist/client-config.d.ts

@@ -2,15 +2,15 @@
  * Pre-connection client-config lookup.
  *
  * `GET client-config` (relative to the agent's base URL — see
- * `sdk/client-config.ts` in `@alexkroman1/aai`) tells the default client how
- * to talk to the agent before any connection exists, most importantly which
- * transport `agent({ transport })` declared. Every failure path — network
- * error, 404 from an older server, malformed body — degrades to the
- * WebSocket default, so this lookup can never break an existing agent.
+ * `sdk/client-config.ts` in `@alexkroman1/aai`) gives the default client the
+ * agent's display name and greeting before any connection exists. Every
+ * failure path — network error, 404 from an older server, malformed body —
+ * degrades to the empty default, so this lookup can never break an existing
+ * agent.
  */
 import { type ClientConfigResponse } from "@alexkroman1/aai/protocol";
 export type { ClientConfigResponse } from "@alexkroman1/aai/protocol";
 /** Resolve a relative endpoint path against the agent's base URL. */
 export declare function buildAgentUrl(platformUrl: string, endpointPath: string): URL;
-/** Fetch the agent's client config; any failure yields the WebSocket default. */
+/** Fetch the agent's client config; any failure yields the agent default. */
 export declare function fetchClientConfig(platformUrl: string, fetchFn?: typeof globalThis.fetch): Promise<ClientConfigResponse>;

package/dist/components/chat-view.d.ts

@@ -1,12 +1,5 @@
+/** @jsxImportSource react */
 import type { ReactNode } from "react";
-import type { AgentState } from "../types.ts";
-/**
- * Indicator dot color per state, on the light refresh palette. Shared with
- * the sync-transport chat shell's status eyebrow.
- *
- * @internal
- */
-export declare function stateColor(state: AgentState, primary: string): string;
 /**
  * The main chat interface for a voice agent session — the design-system
  * "voice agent console": a 760px column on the cream page with a header

package/dist/components/chat-view.js

@@ -1,3 +1,3 @@
 import "../context.js";
-import { n as stateColor, t as ChatView } from "../chat-view-gi6FccZq.js";
-export { ChatView, stateColor };
+import { t as ChatView } from "../chat-view-C1oJxsWz.js";
+export { ChatView };

package/dist/components/console-shell.d.ts

@@ -0,0 +1,37 @@
+import type { ReactNode } from "react";
+import type { AgentState } from "../types.ts";
+/**
+ * Indicator dot color per state, on the light refresh palette.
+ *
+ * @internal
+ */
+export declare function stateColor(state: AgentState, primary: string): string;
+/**
+ * The design-system "console" chrome for the chat shell:
+ * a 760px column on the cream page with a header
+ * (logo + live-status eyebrow), an optional error banner, the main content
+ * on a raised white card, and a footer row beneath it.
+ *
+ * Extracted so the two default surfaces stay visually identical by
+ * construction — they used to be hand-copied down to the same `boxShadow`
+ * literal, and drifted.
+ *
+ * @internal
+ */
+export declare function ConsoleShell({ icon, title, state, pulsing, error, children, footer, className, }: {
+    /** Element rendered in place of the logo in the header. */
+    icon?: ReactNode | undefined;
+    /** Title string for the header. */
+    title?: string | undefined;
+    /** Live status shown in the header eyebrow. */
+    state: AgentState;
+    /** Whether the status dot pulses. */
+    pulsing: boolean;
+    /** Error banner text; `null`/`undefined` hides the banner. */
+    error?: string | null | undefined;
+    /** Card content. */
+    children: ReactNode;
+    /** Row rendered beneath the card (controls). */
+    footer: ReactNode;
+    className?: string | undefined;
+}): ReactNode;

package/dist/components/controls.js

@@ -1,3 +1,3 @@
 import "../context.js";
-import { t as Controls } from "../controls-BbZcmnJf.js";
+import { t as Controls } from "../controls-DV368uhb.js";
 export { Controls };

package/dist/components/url-chips.d.ts

@@ -4,9 +4,6 @@
  * The label is what makes a pair of these readable — on its own a bare URL
  * leaves you guessing whether it's the page or the socket.
  *
- * Exported for the sync-transport shell, which labels its HTTP endpoint
- * without a session snapshot to read from.
- *
  * @internal
  */
 export declare function UrlChip({ label, url, hint, testId, className, }: {
@@ -37,7 +34,7 @@ export declare function ApiUrlChip({ className }: {
  * The UI and API URLs side by side. They answer the same question — "how do I
  * reach this agent?" — so they belong together and each needs its label to be
  * told apart. Rendered by the default shell in every session mode (S2S,
- * pipeline, text-only).
+ * pipeline).
  *
  * @public
  */

package/dist/context.d.ts

@@ -7,7 +7,7 @@ export declare function SessionProvider({ value, children }: {
 }): import("react").FunctionComponentElement<import("react").ProviderProps<SessionCore | null>>;
 /** The session snapshot merged with the core's control methods. Method
  *  signatures come from {@link SessionCore} — one source of truth. */
-export type Session = SessionSnapshot & Pick<SessionCore, "start" | "cancel" | "resetState" | "reset" | "disconnect" | "toggle" | "startRecording" | "stopRecording" | "sendAudioFile">;
+export type Session = SessionSnapshot & Pick<SessionCore, "start" | "cancel" | "resetState" | "reset" | "disconnect" | "toggle">;
 /**
  * Return the raw {@link SessionCore} from context without subscribing to
  * snapshot changes. Useful for accessing stable methods (`start`, `toggle`,