@alexkroman1/aai-ui 1.9.2 → 1.11.0

package/dist/sync-session.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Sync-mode browser session — HTTP turns, no WebSocket.
+ *
+ * The client half of the server's `POST /sync` endpoint (see
+ * `host/sync-turn.ts` in `@alexkroman1/aai`): each turn is one request
+ * carrying committed text or one endpointed utterance of PCM16 audio plus
+ * the conversation history, answered with the transcript, the reply text,
+ * and (when the agent's TTS provider supports one-shot synthesis) the
+ * spoken reply. The server holds no session state — this object owns the
+ * history and replays it every turn.
+ *
+ * Microphone capture and utterance endpointing live in `sync-mic.ts` /
+ * `sync-vad.ts`; this module is transport only, so it also runs in
+ * non-browser clients that bring their own audio.
+ */
+import { type SyncHistoryMessage, type SyncTurnResponse } from "@alexkroman1/aai/protocol";
+/** Base64-encode PCM16 samples (chunked — `btoa` takes a binary string). */
+export declare function pcm16ToBase64(pcm: Int16Array): string;
+/** Decode base64 PCM16LE (the sync response's `audio` field) into samples. */
+export declare function base64ToPcm16(base64: string): Int16Array;
+/** One completed sync turn: the wire response plus decoded reply audio. */
+export type SyncTurnResult = SyncTurnResponse & {
+    /** Decoded reply audio (PCM16 at `sampleRate`), when the server spoke. */
+    pcm: Int16Array | null;
+};
+/** Configuration for {@link createSyncSession}. */
+export type SyncSessionOptions = {
+    /** The agent server's sync endpoint, e.g. `http://localhost:3000/sync`. */
+    url: string;
+    /** Fetch override (tests / custom transports). */
+    fetch?: typeof globalThis.fetch | undefined;
+    /** Called after every completed turn (text and voice alike). */
+    onTurn?: ((turn: SyncTurnResult) => void) | undefined;
+    /** Called when a turn fails; the rejection still propagates to the caller. */
+    onError?: ((err: Error) => void) | undefined;
+};
+/** Sync-mode session handle. */
+export type SyncSession = {
+    /** Conversation so far, oldest first — replayed to the server each turn. */
+    readonly history: readonly SyncHistoryMessage[];
+    /** Run one turn from committed text. */
+    sendText(text: string): Promise<SyncTurnResult>;
+    /** Run one turn from one utterance of mono PCM16 audio. */
+    sendPcm16(pcm: Int16Array, sampleRate: number): Promise<SyncTurnResult>;
+    /** Forget the conversation. */
+    reset(): void;
+};
+/** Create a {@link SyncSession} against a sync-mode agent server. */
+export declare function createSyncSession(opts: SyncSessionOptions): SyncSession;

package/dist/sync-vad.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Client-side utterance detection (VAD) for sync mode.
+ *
+ * Sync mode has no streaming STT to endpoint speech server-side, so the
+ * browser decides where an utterance ends: this module is a pure
+ * energy-based voice-activity state machine fed PCM16 frames (from the
+ * WebRTC capture pipeline in `sync-mic.ts` — `getUserMedia`'s voice
+ * processing handles echo cancellation and noise suppression upstream,
+ * which is what makes a simple RMS gate workable). No browser APIs are
+ * touched here, so the state machine is fully unit-testable.
+ *
+ * Lifecycle per utterance: idle (keeping a pre-roll ring of recent audio)
+ * → candidate speech (voiced frames accumulating toward `minSpeechMs`)
+ * → speaking → `hangoverMs` of silence closes the utterance, which is
+ * returned as one PCM16 buffer including the pre-roll and the hangover
+ * tail (leading context and trailing silence both help one-shot STT).
+ */
+/** Tuning for {@link createUtteranceDetector}. */
+export type UtteranceDetectorOptions = {
+    /** Sample rate of pushed PCM16 frames, in Hz. */
+    sampleRate: number;
+    /** RMS level (0..1 of full scale) a frame must exceed to count as voiced. */
+    speechRms?: number;
+    /** Sustained voiced audio required before an utterance starts. Filters clicks. */
+    minSpeechMs?: number;
+    /** Silence that ends an utterance once one has started. */
+    hangoverMs?: number;
+    /** Audio kept from before speech onset, so a soft first syllable survives. */
+    prerollMs?: number;
+    /** Hard cap: a monologue this long is emitted as an utterance mid-speech. */
+    maxUtteranceMs?: number;
+};
+export declare const DEFAULT_SPEECH_RMS = 0.015;
+export declare const DEFAULT_MIN_SPEECH_MS = 150;
+export declare const DEFAULT_HANGOVER_MS = 700;
+export declare const DEFAULT_PREROLL_MS = 300;
+export declare const DEFAULT_MAX_UTTERANCE_MS = 30000;
+/** Utterance detector — feed PCM16 frames, get complete utterances back. */
+export type UtteranceDetector = {
+    /**
+     * Push one capture frame (any length). Returns a complete utterance when
+     * this frame closed one, else null.
+     */
+    push(frame: Int16Array): Int16Array | null;
+    /** End of stream: returns any in-progress utterance (candidate audio that
+     *  never reached `minSpeechMs` is discarded as noise). */
+    flush(): Int16Array | null;
+    /** True while an utterance is being captured. */
+    readonly speaking: boolean;
+    /** Discard all buffered audio and return to idle. */
+    reset(): void;
+};
+/** Create an energy-based {@link UtteranceDetector}. */
+export declare function createUtteranceDetector(opts: UtteranceDetectorOptions): UtteranceDetector;

package/dist/{tool-call-block-7f1GTG-P.js → tool-call-block-DIxpG8GM.js}

@@ -1,9 +1,9 @@
 import { useTheme } from "./context.js";
-import { r as TEXT_FAINT } from "./_colors-DJUordGv.js";
+import { r as TEXT_FAINT } from "./_colors-DYX7XRTr.js";
 import { t as Eyebrow } from "./eyebrow-C6ZFuiz6.js";
-import { n as tryParseJSON, t as truncate } from "./_utils-5cs73OrA.js";
+import { n as tryParseJSON, t as truncate } from "./_utils-CN1yVgYS.js";
 import clsx from "clsx";
-import { createContext, useContext, useMemo, useState } from "react";
+import { createContext, memo, useContext, useMemo, useState } from "react";
 import { jsx, jsxs } from "react/jsx-runtime";
 //#region components/tool-config-context.ts
 /**
@@ -40,6 +40,10 @@ function formatResult(result) {
 * While the tool call is pending a shimmer animation is shown. Once
 * complete, clicking the row expands the formatted JSON result.
 *
+* Memoized: tool-call objects are referentially stable across session
+* snapshots and rows are keyed on the stable `callId`, so a list update only
+* re-renders the rows whose tool call actually changed.
+*
 * @example
 * ```tsx
 * <ToolCallBlock toolCall={toolCall} />
@@ -50,10 +54,11 @@ function formatResult(result) {
 *
 * @public
 */
-function ToolCallBlock({ toolCall, className }) {
+const ToolCallBlock = memo(function ToolCallBlock({ toolCall, className }) {
 	const [isOpen, setIsOpen] = useState(false);
 	const theme = useTheme();
-	const config = useToolConfig()[toolCall.name];
+	const toolConfig = useToolConfig();
+	const config = Object.hasOwn(toolConfig, toolCall.name) ? toolConfig[toolCall.name] : void 0;
 	const isPending = toolCall.status === "pending";
 	const title = config?.label || toolCall.name;
 	const icon = config?.icon;
@@ -128,6 +133,6 @@ function ToolCallBlock({ toolCall, className }) {
 			})]
 		})]
 	});
-}
+});
 //#endregion
 export { ToolConfigContext as n, ToolCallBlock as t };

package/dist/types.d.ts

@@ -1,15 +1,5 @@
 import type { SessionErrorCode } from "@alexkroman1/aai/protocol";
-/** Microphone buffer duration in seconds before sending to the server. */
-export declare const MIC_BUFFER_SECONDS = 0.1;
-/**
- * Backpressure threshold for outbound mic audio. When the WebSocket's
- * `bufferedAmount` exceeds this many bytes (~2s of 16 kHz PCM16), mic frames
- * are dropped instead of queued — for live voice, stale audio flushed into
- * STT on recovery is worse than a gap.
- */
-export declare const MIC_SEND_MAX_BUFFERED_BYTES: number;
-/** Poll interval while waiting out socket backpressure during a file send. */
-export declare const FILE_SEND_BACKOFF_MS = 50;
+export { FILE_SEND_BACKOFF_MS, MIC_BUFFER_SECONDS, MIC_SEND_MAX_BUFFERED_BYTES, } from "@alexkroman1/aai";
 /**
  * Current state of the voice agent session.
  *
@@ -81,17 +71,25 @@ export type VoiceSessionOptions = {
      * Called when the server sends a session ID in the config message.
      * Use this to store the ID (e.g. in localStorage) for reconnection
      * via `resumeSessionId`.
+     *
+     * Treat session IDs as sensitive: whoever holds one can resume the
+     * session and read its replayed history. They travel as a WebSocket
+     * query parameter (browsers cannot set WS headers), so they may appear
+     * in proxy and server access logs — don't put them in shared URLs.
      */
     onSessionId?: ((sessionId: string) => void) | undefined;
     /**
      * Session ID from a previous connection. When set, the server will
      * attempt to restore persisted session state (if the agent has
-     * `persistence` enabled).
+     * `persistence` enabled). Sensitive — see {@link onSessionId}.
      */
     resumeSessionId?: string | undefined;
     /**
-     * WebSocket constructor override. Defaults to the native `WebSocket`.
-     * Primarily useful for testing with a mock WebSocket.
+     * WebSocket constructor override. Primarily useful for testing with a mock
+     * WebSocket. When omitted, the session uses a reconnecting WebSocket
+     * (partysocket) that retries with exponential backoff after an unexpected
+     * close and resumes the session; an injected constructor is used as-is and
+     * never reconnects on its own.
      */
     WebSocket?: WebSocketConstructor | undefined;
 };

package/dist/types.js

@@ -1,14 +1,2 @@
-//#region types.ts
-/** Microphone buffer duration in seconds before sending to the server. */
-const MIC_BUFFER_SECONDS = .1;
-/**
-* Backpressure threshold for outbound mic audio. When the WebSocket's
-* `bufferedAmount` exceeds this many bytes (~2s of 16 kHz PCM16), mic frames
-* are dropped instead of queued — for live voice, stale audio flushed into
-* STT on recovery is worse than a gap.
-*/
-const MIC_SEND_MAX_BUFFERED_BYTES = 64 * 1024;
-/** Poll interval while waiting out socket backpressure during a file send. */
-const FILE_SEND_BACKOFF_MS = 50;
-//#endregion
+import { FILE_SEND_BACKOFF_MS, MIC_BUFFER_SECONDS, MIC_SEND_MAX_BUFFERED_BYTES } from "@alexkroman1/aai";
 export { FILE_SEND_BACKOFF_MS, MIC_BUFFER_SECONDS, MIC_SEND_MAX_BUFFERED_BYTES };

package/dist/worklets/capture-processor.d.ts

@@ -1,4 +1,4 @@
 /** Raw worklet source — exported so tests can evaluate the processor directly. */
-export declare const captureProcessorSource = "\nclass CaptureProcessor extends AudioWorkletProcessor {\n  constructor(options) {\n    super();\n    this.recording = false;\n    const opts = options.processorOptions || {};\n    this.fromRate = opts.contextRate || sampleRate;\n    this.toRate = opts.sttSampleRate || sampleRate;\n    this.ratio = this.fromRate / this.toRate;\n    this.needsResample = this.fromRate !== this.toRate;\n    // Streaming-resampler state carried across process() blocks so the output\n    // clock doesn't drift and there's no discontinuity at 128-sample block\n    // boundaries. `prev` is the previous block's last input sample (used to\n    // interpolate across the boundary); `pos` is the fractional read position,\n    // in input samples, relative to an extended [prev, ...input] frame. Start\n    // at 1 so the first output is input[0] (not the bogus initial prev).\n    this.prev = 0;\n    this.pos = 1;\n    // Output buffer reused across process() calls -- the render quantum is a\n    // fixed size, so allocating per call would churn the realtime audio thread.\n    this.resampleBuf = null;\n    // Int16 accumulation buffer: flushed to the main thread as one transferred\n    // ArrayBuffer once ~bufferSeconds of output samples are batched. Sized 2x\n    // the flush target so a whole render quantum always fits before flushing.\n    this.targetSamples = Math.max(1, Math.round(this.toRate * (opts.bufferSeconds || 0.1)));\n    this.pending = new Int16Array(this.targetSamples * 2);\n    this.pendingLen = 0;\n    this.port.onmessage = (e) => {\n      if (e.data.event === 'start') this.recording = true;\n      else if (e.data.event === 'stop') {\n        // Final flush so the tail of speech isn't dropped on close.\n        this.flush();\n        this.recording = false;\n      }\n    };\n  }\n\n  resample(input) {\n    const ratio = this.ratio;\n    const n = input.length;\n    if (n === 0) return new Float32Array(0);\n    // At most ceil(n / ratio) + 1 outputs per block (pos starts in [0, ratio)).\n    const maxLen = Math.ceil(n / ratio) + 1;\n    if (this.resampleBuf === null || this.resampleBuf.length < maxLen) {\n      this.resampleBuf = new Float32Array(maxLen);\n    }\n    const out = this.resampleBuf;\n    // Extended frame: index 0 = prev (previous block's last sample),\n    // index k>=1 = input[k-1]. Interpolate at fractional positions stepping by\n    // ratio, carrying `pos` across calls to preserve the sample clock.\n    let count = 0;\n    let pos = this.pos;\n    while (pos < n) {\n      const idx = pos | 0;\n      const frac = pos - idx;\n      const a = idx === 0 ? this.prev : input[idx - 1];\n      const b = input[idx];\n      out[count++] = a + frac * (b - a);\n      pos += ratio;\n    }\n    // Shift the origin to this block's last sample for the next call.\n    this.prev = input[n - 1];\n    this.pos = pos - n;\n    return out.subarray(0, count);\n  }\n\n  // Convert Float32 -> Int16 and append to the pending batch. Writes through\n  // an Int16Array directly (assignment truncates like DataView.setInt16).\n  accumulate(samples) {\n    let buf = this.pending;\n    if (this.pendingLen + samples.length > buf.length) {\n      // Defensive: only reachable if a render quantum outproduces the 1x\n      // headroom above the flush target (never with 128-sample quanta).\n      const grown = new Int16Array((this.pendingLen + samples.length) * 2);\n      grown.set(buf.subarray(0, this.pendingLen));\n      this.pending = grown;\n      buf = grown;\n    }\n    for (let i = 0; i < samples.length; i++) {\n      const s = Math.max(-1, Math.min(1, samples[i]));\n      buf[this.pendingLen++] = s < 0 ? s * 0x8000 : s * 0x7fff;\n    }\n  }\n\n  // Post the batched samples as one transferred ArrayBuffer and reset.\n  flush() {\n    if (this.pendingLen === 0) return;\n    const buffer = this.pending.buffer.slice(0, this.pendingLen * 2);\n    this.pendingLen = 0;\n    this.port.postMessage({ event: 'chunk', buffer }, [buffer]);\n  }\n\n  process(inputs) {\n    const input = inputs[0];\n    if (!input || !input[0] || !this.recording) return true;\n\n    const samples = this.needsResample ? this.resample(input[0]) : input[0];\n    this.accumulate(samples);\n    if (this.pendingLen >= this.targetSamples) this.flush();\n    return true;\n  }\n}\n\nregisterProcessor('capture-processor', CaptureProcessor);\n";
+export declare const captureProcessorSource = "\nclass CaptureProcessor extends AudioWorkletProcessor {\n  constructor(options) {\n    super();\n    this.recording = false;\n    const opts = options.processorOptions || {};\n    this.fromRate = opts.contextRate || sampleRate;\n    this.toRate = opts.sttSampleRate || sampleRate;\n    this.ratio = this.fromRate / this.toRate;\n    this.needsResample = this.fromRate !== this.toRate;\n    // Streaming-resampler state carried across process() blocks so the output\n    // clock doesn't drift and there's no discontinuity at 128-sample block\n    // boundaries. `prev` is the previous block's last input sample (used to\n    // interpolate across the boundary); `pos` is the fractional read position,\n    // in input samples, relative to an extended [prev, ...input] frame. Start\n    // at 1 so the first output is input[0] (not the bogus initial prev).\n    this.prev = 0;\n    this.pos = 1;\n    // Output buffer reused across process() calls -- the render quantum is a\n    // fixed size, so allocating per call would churn the realtime audio thread.\n    this.resampleBuf = null;\n    // Int16 accumulation buffer: flushed to the main thread as one transferred\n    // ArrayBuffer once ~bufferSeconds of output samples are batched. Sized 2x\n    // the flush target so a whole render quantum always fits before flushing.\n    this.targetSamples = Math.max(1, Math.round(this.toRate * (opts.bufferSeconds || 0.1)));\n    this.pending = new Int16Array(this.targetSamples * 2);\n    this.pendingLen = 0;\n    this.port.onmessage = (e) => {\n      if (e.data.event === 'start') this.recording = true;\n      else if (e.data.event === 'stop') {\n        // Final flush so the tail of speech isn't dropped on close, then ack\n        // so the host knows the tail chunk (if any) has been posted and it is\n        // safe to tear the context down.\n        this.flush();\n        this.recording = false;\n        this.port.postMessage({ event: 'stopped' });\n      }\n    };\n  }\n\n  resample(input) {\n    const ratio = this.ratio;\n    const n = input.length;\n    if (n === 0) return new Float32Array(0);\n    // At most ceil(n / ratio) + 1 outputs per block (pos starts in [0, ratio)).\n    const maxLen = Math.ceil(n / ratio) + 1;\n    if (this.resampleBuf === null || this.resampleBuf.length < maxLen) {\n      this.resampleBuf = new Float32Array(maxLen);\n    }\n    const out = this.resampleBuf;\n    // Extended frame: index 0 = prev (previous block's last sample),\n    // index k>=1 = input[k-1]. Interpolate at fractional positions stepping by\n    // ratio, carrying `pos` across calls to preserve the sample clock.\n    let count = 0;\n    let pos = this.pos;\n    while (pos < n) {\n      const idx = pos | 0;\n      const frac = pos - idx;\n      const a = idx === 0 ? this.prev : input[idx - 1];\n      const b = input[idx];\n      out[count++] = a + frac * (b - a);\n      pos += ratio;\n    }\n    // Shift the origin to this block's last sample for the next call.\n    this.prev = input[n - 1];\n    this.pos = pos - n;\n    return out.subarray(0, count);\n  }\n\n  // Convert Float32 -> Int16 and append to the pending batch. Writes through\n  // an Int16Array directly (assignment truncates like DataView.setInt16).\n  accumulate(samples) {\n    let buf = this.pending;\n    if (this.pendingLen + samples.length > buf.length) {\n      // Defensive: only reachable if a render quantum outproduces the 1x\n      // headroom above the flush target (never with 128-sample quanta).\n      const grown = new Int16Array((this.pendingLen + samples.length) * 2);\n      grown.set(buf.subarray(0, this.pendingLen));\n      this.pending = grown;\n      buf = grown;\n    }\n    for (let i = 0; i < samples.length; i++) {\n      const s = Math.max(-1, Math.min(1, samples[i]));\n      buf[this.pendingLen++] = s < 0 ? s * 0x8000 : s * 0x7fff;\n    }\n  }\n\n  // Post the batched samples as one transferred ArrayBuffer and reset.\n  flush() {\n    if (this.pendingLen === 0) return;\n    const buffer = this.pending.buffer.slice(0, this.pendingLen * 2);\n    this.pendingLen = 0;\n    this.port.postMessage({ event: 'chunk', buffer }, [buffer]);\n  }\n\n  process(inputs) {\n    const input = inputs[0];\n    if (!input || !input[0] || !this.recording) return true;\n\n    const samples = this.needsResample ? this.resample(input[0]) : input[0];\n    this.accumulate(samples);\n    if (this.pendingLen >= this.targetSamples) this.flush();\n    return true;\n  }\n}\n\nregisterProcessor('capture-processor', CaptureProcessor);\n";
 declare const src: string;
 export default src;

package/dist/worklets/capture-processor.js

@@ -29,9 +29,12 @@ class CaptureProcessor extends AudioWorkletProcessor {
     this.port.onmessage = (e) => {
       if (e.data.event === 'start') this.recording = true;
       else if (e.data.event === 'stop') {
-        // Final flush so the tail of speech isn't dropped on close.
+        // Final flush so the tail of speech isn't dropped on close, then ack
+        // so the host knows the tail chunk (if any) has been posted and it is
+        // safe to tear the context down.
         this.flush();
         this.recording = false;
+        this.port.postMessage({ event: 'stopped' });
       }
     };
   }

package/dist/worklets/playback-processor.d.ts

@@ -1,4 +1,4 @@
 /** Raw worklet source — exported so tests can evaluate the processor directly. */
-export declare const playbackProcessorSource = "\nclass PlaybackProcessor extends AudioWorkletProcessor {\n  constructor(options) {\n    super();\n    const rate = options.processorOptions?.sampleRate ?? 24000;\n    // Wait for ~400ms of audio before starting.\n    // If 'done' arrives first (short utterance), start immediately.\n    this.jitterSamples = Math.floor(rate * 0.4);\n    // Float32 ring buffer \u2014 60s at the context sample rate. Allocated once for\n    // the node's lifetime; per-turn state resets via resetTurn(). writePos and\n    // readPos are absolute (monotonic) sample counts; the buffer is indexed\n    // modulo capacity so a reply longer than 60s keeps playing instead of\n    // writing past the end and going silent.\n    this.capacity = rate * 60;\n    this.samples = new Float32Array(this.capacity);\n    // Platform endianness probe: the wire format is PCM16 little-endian, so\n    // the Int16Array fast path in ingestBytes is only valid on LE hosts\n    // (every shipping browser target; the DataView path is the fallback).\n    this.littleEndian = new Uint8Array(new Uint16Array([1]).buffer)[0] === 1;\n    this.resetTurn();\n\n    this.port.onmessage = (e) => {\n      const d = e.data;\n      if (d.event === 'write') {\n        this.ingestBytes(d.buffer);\n      } else if (d.event === 'interrupt') {\n        this.interrupted = true;\n      } else if (d.event === 'done') {\n        this.isDone = true;\n      }\n    };\n  }\n\n  // Reset per-turn state so the node is reusable across replies without\n  // reallocating the sample buffer or re-instantiating the worklet.\n  resetTurn() {\n    this.interrupted = false;\n    this.isDone = false;\n    this.playing = false;\n    // Carry-over byte for split samples across chunks\n    this.carry = null;\n    this.writePos = 0;\n    this.readPos = 0;\n  }\n\n  // End the current turn: notify the host and rearm for the next reply.\n  // Must NOT return false from process() \u2014 a processor that stops is dead\n  // for good, forcing a new node (and buffer) per reply.\n  stopTurn() {\n    this.port.postMessage({ event: 'stop' });\n    this.resetTurn();\n  }\n\n  ingestBytes(uint8) {\n    let bytes = uint8;\n\n    if (this.carry !== null) {\n      const merged = new Uint8Array(1 + bytes.length);\n      merged[0] = this.carry;\n      merged.set(bytes, 1);\n      bytes = merged;\n      this.carry = null;\n    }\n\n    if (bytes.length % 2 !== 0) {\n      this.carry = bytes[bytes.length - 1];\n      bytes = bytes.subarray(0, bytes.length - 1);\n    }\n\n    if (bytes.length === 0) return;\n    const numSamples = bytes.length / 2;\n    const cap = this.capacity;\n    const samples = this.samples;\n    if (this.littleEndian && (bytes.byteOffset & 1) === 0) {\n      // Fast path: 2-byte-aligned LE bytes wrap directly as an Int16Array;\n      // copy wrap-aware in at most two runs with no per-sample DataView call\n      // or modulo. This runs on the realtime audio thread.\n      const int16 = new Int16Array(bytes.buffer, bytes.byteOffset, numSamples);\n      let src = 0;\n      let dst = this.writePos % cap;\n      while (src < numSamples) {\n        const run = Math.min(numSamples - src, cap - dst);\n        for (let j = 0; j < run; j++) {\n          samples[dst + j] = int16[src + j] / 0x8000;\n        }\n        src += run;\n        dst = 0;\n      }\n    } else {\n      // Odd byte offset (or big-endian host): fall back to per-sample reads.\n      const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.length);\n      let dst = this.writePos % cap;\n      for (let i = 0; i < numSamples; i++) {\n        samples[dst] = view.getInt16(i * 2, true) / 0x8000;\n        dst++;\n        if (dst === cap) dst = 0;\n      }\n    }\n    this.writePos += numSamples;\n    // If the producer outran the consumer by more than the buffer holds, drop\n    // the oldest unplayed audio rather than reading samples we've overwritten.\n    if (this.writePos - this.readPos > this.capacity) {\n      this.readPos = this.writePos - this.capacity;\n    }\n  }\n\n  process(inputs, outputs) {\n    const out = outputs[0][0];\n    if (this.interrupted) {\n      out.fill(0);\n      this.stopTurn();\n      return true;\n    }\n\n    const avail = this.writePos - this.readPos;\n\n    // Wait for jitter buffer to fill, unless done (short utterance)\n    if (!this.playing) {\n      if (avail >= this.jitterSamples || this.isDone) {\n        this.playing = true;\n      } else {\n        out.fill(0);\n        return true;\n      }\n    }\n\n    if (avail > 0) {\n      const n = Math.min(avail, out.length);\n      // Copy from the ring buffer, splitting across the wrap boundary.\n      const start = this.readPos % this.capacity;\n      const first = Math.min(n, this.capacity - start);\n      out.set(this.samples.subarray(start, start + first), 0);\n      if (n > first) out.set(this.samples.subarray(0, n - first), first);\n      this.readPos += n;\n      out.fill(0, n);\n      return true;\n    }\n\n    // No data: output silence, end the turn only when done\n    out.fill(0);\n    if (this.isDone) {\n      this.stopTurn();\n    }\n    return true;\n  }\n}\n\nregisterProcessor('playback-processor', PlaybackProcessor);\n";
+export declare const playbackProcessorSource = "\nclass PlaybackProcessor extends AudioWorkletProcessor {\n  constructor(options) {\n    super();\n    const rate = options.processorOptions?.sampleRate ?? 24000;\n    // Wait for ~400ms of audio before starting.\n    // If 'done' arrives first (short utterance), start immediately.\n    this.jitterSamples = Math.floor(rate * 0.4);\n    // Float32 ring buffer \u2014 60s at the context sample rate. Allocated once for\n    // the node's lifetime; per-turn state resets via resetTurn(). writePos and\n    // readPos are absolute (monotonic) sample counts; the buffer is indexed\n    // modulo capacity so a reply longer than 60s keeps playing instead of\n    // writing past the end and going silent.\n    this.capacity = rate * 60;\n    this.samples = new Float32Array(this.capacity);\n    // Platform endianness probe: the wire format is PCM16 little-endian, so\n    // the Int16Array fast path in ingestBytes is only valid on LE hosts\n    // (every shipping browser target; the DataView path is the fallback).\n    this.littleEndian = new Uint8Array(new Uint16Array([1]).buffer)[0] === 1;\n    this.resetTurn();\n\n    this.port.onmessage = (e) => {\n      const d = e.data;\n      if (d.event === 'write') {\n        this.ingestBytes(d.buffer);\n      } else if (d.event === 'interrupt') {\n        this.interrupted = true;\n      } else if (d.event === 'done') {\n        this.isDone = true;\n      }\n    };\n  }\n\n  // Reset per-turn state so the node is reusable across replies without\n  // reallocating the sample buffer or re-instantiating the worklet.\n  resetTurn() {\n    this.interrupted = false;\n    this.isDone = false;\n    this.playing = false;\n    // Carry-over byte for split samples across chunks\n    this.carry = null;\n    this.writePos = 0;\n    this.readPos = 0;\n  }\n\n  // End the current turn: notify the host and rearm for the next reply.\n  // Must NOT return false from process() \u2014 a processor that stops is dead\n  // for good, forcing a new node (and buffer) per reply.\n  // `reason` ('interrupt' | 'done') tells the host which turn boundary this\n  // stop belongs to: interrupt-stops are dropped host-side (flush() already\n  // settled that turn), so they can never resolve a later turn's done() early.\n  stopTurn(reason) {\n    this.port.postMessage({ event: 'stop', reason });\n    this.resetTurn();\n  }\n\n  ingestBytes(uint8) {\n    let bytes = uint8;\n\n    if (this.carry !== null) {\n      const merged = new Uint8Array(1 + bytes.length);\n      merged[0] = this.carry;\n      merged.set(bytes, 1);\n      bytes = merged;\n      this.carry = null;\n    }\n\n    if (bytes.length % 2 !== 0) {\n      this.carry = bytes[bytes.length - 1];\n      bytes = bytes.subarray(0, bytes.length - 1);\n    }\n\n    if (bytes.length === 0) return;\n    const numSamples = bytes.length / 2;\n    const cap = this.capacity;\n    const samples = this.samples;\n    if (this.littleEndian && (bytes.byteOffset & 1) === 0) {\n      // Fast path: 2-byte-aligned LE bytes wrap directly as an Int16Array;\n      // copy wrap-aware in at most two runs with no per-sample DataView call\n      // or modulo. This runs on the realtime audio thread.\n      const int16 = new Int16Array(bytes.buffer, bytes.byteOffset, numSamples);\n      let src = 0;\n      let dst = this.writePos % cap;\n      while (src < numSamples) {\n        const run = Math.min(numSamples - src, cap - dst);\n        for (let j = 0; j < run; j++) {\n          samples[dst + j] = int16[src + j] / 0x8000;\n        }\n        src += run;\n        dst = 0;\n      }\n    } else {\n      // Odd byte offset (or big-endian host): fall back to per-sample reads.\n      const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.length);\n      let dst = this.writePos % cap;\n      for (let i = 0; i < numSamples; i++) {\n        samples[dst] = view.getInt16(i * 2, true) / 0x8000;\n        dst++;\n        if (dst === cap) dst = 0;\n      }\n    }\n    this.writePos += numSamples;\n    // If the producer outran the consumer by more than the buffer holds, drop\n    // the oldest unplayed audio rather than reading samples we've overwritten.\n    if (this.writePos - this.readPos > this.capacity) {\n      this.readPos = this.writePos - this.capacity;\n    }\n  }\n\n  process(inputs, outputs) {\n    // No output wired up yet \u2014 nothing to render this quantum. Throwing here\n    // would permanently kill the processor (the node is persistent per\n    // session), so guard like the capture processor does.\n    if (!outputs[0] || !outputs[0][0]) return true;\n    const out = outputs[0][0];\n    if (this.interrupted) {\n      out.fill(0);\n      this.stopTurn('interrupt');\n      return true;\n    }\n\n    const avail = this.writePos - this.readPos;\n\n    // Wait for jitter buffer to fill, unless done (short utterance)\n    if (!this.playing) {\n      if (avail >= this.jitterSamples || this.isDone) {\n        this.playing = true;\n      } else {\n        out.fill(0);\n        return true;\n      }\n    }\n\n    if (avail > 0) {\n      const n = Math.min(avail, out.length);\n      // Copy from the ring buffer, splitting across the wrap boundary.\n      const start = this.readPos % this.capacity;\n      const first = Math.min(n, this.capacity - start);\n      out.set(this.samples.subarray(start, start + first), 0);\n      if (n > first) out.set(this.samples.subarray(0, n - first), first);\n      this.readPos += n;\n      out.fill(0, n);\n      return true;\n    }\n\n    // No data: output silence, end the turn only when done\n    out.fill(0);\n    if (this.isDone) {\n      this.stopTurn('done');\n    }\n    return true;\n  }\n}\n\nregisterProcessor('playback-processor', PlaybackProcessor);\n";
 declare const src: string;
 export default src;

package/dist/worklets/playback-processor.js

@@ -47,8 +47,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();
   }
 
@@ -106,10 +109,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;
     }
 
@@ -140,7 +147,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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alexkroman1/aai-ui",
-  "version": "1.9.2",
+  "version": "1.11.0",
   "type": "module",
   "files": [
     "dist",
@@ -18,12 +18,14 @@
   },
   "dependencies": {
     "clsx": "^2.1.1",
-    "@alexkroman1/aai": "1.9.2"
+    "partysocket": "^1.3.0",
+    "use-sync-external-store": "^1.6.0",
+    "@alexkroman1/aai": "1.11.0"
   },
   "peerDependencies": {
-    "react": "^19.2.8",
-    "react-dom": "^19.2.8",
-    "tailwindcss": "^4.3.2"
+    "react": "^19.0.0",
+    "react-dom": "^19.0.0",
+    "tailwindcss": "^4.0.0"
   },
   "peerDependenciesMeta": {
     "tailwindcss": {
@@ -36,6 +38,7 @@
     "@testing-library/react": "^16.3.2",
     "@types/react": "^19.2.17",
     "@types/react-dom": "^19.2.3",
+    "@types/use-sync-external-store": "^1.5.0",
     "@vitejs/plugin-react": "^6.0.4",
     "jsdom": "^29.1.1",
     "react": "^19.2.8",

package/dist/default-client/assets/audio-Cs-6t_Wd.js

@@ -1 +0,0 @@
-import{t as e}from"./index-Bf4ZTNcx.js";async function t(e,t){let n=await new OfflineAudioContext(1,1,t).decodeAudioData(e),r=Math.ceil(n.duration*t),i=new OfflineAudioContext(1,r,t),a=i.createBufferSource();a.buffer=n,a.connect(i.destination),a.start();let o=(await i.startRendering()).getChannelData(0),s=new Int16Array(o.length);for(let e=0;e<o.length;e++){let t=Math.max(-1,Math.min(1,o[e]??0));s[e]=t<0?t*32768:t*32767}return s}async function n(t){let{sttSampleRate:n,ttsSampleRate:r,captureWorkletSrc:i,playbackWorkletSrc:a,onMicData:o}=t,s=r,c=new AudioContext({sampleRate:s,latencyHint:`playback`}),l=navigator.mediaDevices.getUserMedia({audio:{deviceId:{ideal:`default`},echoCancellation:!0,noiseSuppression:!0,autoGainControl:!0,voiceIsolation:!0}}),u;try{[u]=await Promise.all([l,c.resume(),c.audioWorklet.addModule(i),c.audioWorklet.addModule(a)])}catch(e){throw l.then(e=>{for(let t of e.getTracks())t.stop()}).catch(()=>{}),await c.close().catch(e=>{console.warn(`AudioContext close failed:`,e)}),e}let d=c.createMediaStreamSource(u),f=new AudioWorkletNode(c,`capture-processor`,{channelCount:1,channelCountMode:`explicit`,processorOptions:{contextRate:s,sttSampleRate:n,bufferSeconds:e}});d.connect(f),f.port.postMessage({event:`start`}),f.port.onmessage=e=>{e.data.event===`chunk`&&o(e.data.buffer)};let p=null,m=null,h=new AbortController;function g(){if(p)return p;let e=new AudioWorkletNode(c,`playback-processor`,{processorOptions:{sampleRate:s}});return e.connect(c.destination),e.port.onmessage=e=>{e.data.event===`stop`&&(m?.(),m=null)},p=e,e}let _={enqueue(e){h.signal.aborted||e.byteLength!==0&&g().port.postMessage({event:`write`,buffer:new Uint8Array(e)},[e])},done(){return!p||c.state!==`running`?Promise.resolve():new Promise(e=>{m=e,p?.port.postMessage({event:`done`})})},flush(){p&&p.port.postMessage({event:`interrupt`})},async close(){if(!h.signal.aborted){h.abort(),f.port.postMessage({event:`stop`}),d.disconnect(),f.disconnect(),p&&p.disconnect();for(let e of u.getTracks())e.stop();await c.close().catch(()=>{})}},async[Symbol.asyncDispose](){await _.close()}};return _}export{n as createVoiceIO,t as decodeAudioToPcm16};