@alexkroman1/aai-ui 1.16.0 → 3.0.0

package/dist/session-core-upload.d.ts

@@ -1,16 +0,0 @@
-import type { ClientMessage } from "@alexkroman1/aai/protocol";
-import type { ConnState, SessionSnapshot } from "./session-core-types.ts";
-/** Handle to the upload pipeline, owned by one session core. */
-export type UploadSender = {
-    /** See {@link SessionCore.sendAudioFile}. */
-    sendAudioFile(file: Blob): Promise<void>;
-    /** True while an upload is decoding or streaming — the mic must stay off. */
-    inFlight(): boolean;
-    /** Invalidate any in-flight upload (reset / close / reconnect). */
-    discard(): void;
-};
-export declare function createUploadSender(deps: {
-    conn: ConnState;
-    getSnapshot: () => SessionSnapshot;
-    sendJson: (msg: ClientMessage) => void;
-}): UploadSender;

package/dist/sync-mic.d.ts

@@ -1,93 +0,0 @@
-/**
- * WebRTC microphone capture for sync mode.
- *
- * Captures voice through `getUserMedia` with the WebRTC voice-processing
- * constraints (echo cancellation, noise suppression, auto gain — the
- * processing that makes the energy VAD in `sync-vad.ts` reliable), runs an
- * AudioWorklet that batches raw frames to the main thread, feeds them
- * through the utterance detector, and hands each completed utterance to
- * the sync session as one HTTP turn. No WebSocket anywhere on the path.
- *
- * The worklet module ships inline as a blob URL (same pattern as the
- * WebSocket path's worklets), so sync mode needs no separately-served
- * processor file. 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 "Unable to load a worklet's module".
- */
-import type { SyncSession } from "./sync-session.ts";
-import { type UtteranceDetectorOptions } from "./sync-vad.ts";
-/** Default capture rate — what the STT providers expect. */
-export declare const DEFAULT_SYNC_MIC_SAMPLE_RATE = 16000;
-/** ~128 ms at 16 kHz: few messages per second, fine-enough VAD granularity. */
-export declare const CAPTURE_BATCH_SAMPLES = 2048;
-/**
- * The capture processor: coalesces 128-sample render quanta into
- * {@link CAPTURE_BATCH_SAMPLES} batches and posts them (transferred, so no
- * per-batch copy). Inlined as source because it must be stringified into a
- * blob URL.
- *
- * `batch` is held as a field rather than re-read from the posted view:
- * `postMessage` with a transfer list detaches the buffer, so `out.length` is
- * 0 by the time the next buffer is allocated. Allocating a zero-length `buf`
- * from it made `n` 0 forever, so `read` stopped advancing and the render
- * thread spun inside `process()` posting empty chunks — the mic went
- * permanently deaf on its first flush.
- *
- * Exported for the worklet unit tests (`sync-mic-worklet.test.ts`), which
- * evaluate this source directly; it is not part of the package surface.
- */
-export declare const CAPTURE_PROCESSOR_SRC = "\nregisterProcessor(\"aai-sync-capture\", class extends AudioWorkletProcessor {\n  constructor(options) {\n    super();\n    const batch = (options && options.processorOptions && options.processorOptions.batchSamples) || 2048;\n    this.batch = batch;\n    this.buf = new Float32Array(batch);\n    this.len = 0;\n  }\n  process(inputs) {\n    const ch = inputs[0] && inputs[0][0];\n    if (!ch) return true;\n    let read = 0;\n    while (read < ch.length) {\n      const n = Math.min(ch.length - read, this.buf.length - this.len);\n      this.buf.set(ch.subarray(read, read + n), this.len);\n      this.len += n;\n      read += n;\n      if (this.len === this.batch) {\n        const out = this.buf;\n        // Size the next buffer from this.batch, never from `out`: the\n        // transfer below detaches out.buffer, so out.length reads 0 here.\n        this.buf = new Float32Array(this.batch);\n        this.len = 0;\n        this.port.postMessage({ event: \"chunk\", samples: out }, [out.buffer]);\n      }\n    }\n    return true;\n  }\n});\n";
-/**
- * Blob-URL module for the capture processor (no served asset). Satisfies the
- * agent page's `script-src blob:` CSP, which rejects data-URI modules.
- */
-export declare const CAPTURE_WORKLET_MODULE_URL: string;
-/** Clamp-and-convert one Float32 capture batch to PCM16. */
-export declare function floatToPcm16(samples: Float32Array): Int16Array;
-/** Configuration for {@link startSyncMicrophone}. */
-export type SyncMicrophoneOptions = {
-    /** The session each completed utterance is sent through. */
-    session: Pick<SyncSession, "sendPcm16">;
-    /** Capture/STT sample rate. Defaults to {@link DEFAULT_SYNC_MIC_SAMPLE_RATE}. */
-    sampleRate?: number | undefined;
-    /** VAD tuning overrides (see {@link UtteranceDetectorOptions}). */
-    vad?: Omit<UtteranceDetectorOptions, "sampleRate"> | undefined;
-    /** Speech onset confirmed — a turn will follow once the user pauses. */
-    onSpeechStart?: (() => void) | undefined;
-    /** An utterance was endpointed and its turn dispatched. */
-    onSpeechEnd?: (() => void) | undefined;
-    /** Capture or turn failure (the mic keeps running unless stopped). */
-    onError?: ((err: Error) => void) | undefined;
-};
-/** Live microphone handle returned by {@link startSyncMicrophone}. */
-export type SyncMicrophone = {
-    /** True while the detector is inside an utterance. */
-    readonly speaking: boolean;
-    /** Release the mic, the AudioContext, and flush a trailing utterance. */
-    stop(): Promise<void>;
-};
-/** Hold-to-record handle returned by {@link createPttRecorder}. */
-export type PttRecorder = {
-    /** Open the mic (first call) and start collecting frames. */
-    start(): Promise<void>;
-    /** Stop collecting and return everything recorded since `start()` as PCM16. */
-    stop(): Promise<Int16Array>;
-    /** Release the mic and the AudioContext. */
-    close(): Promise<void>;
-};
-/**
- * Push-to-talk recorder on the same WebRTC capture pipeline as
- * {@link startSyncMicrophone} — `getUserMedia` voice processing feeding the
- * capture worklet — minus the VAD: the caller's button is the endpointing.
- * Recording runs exactly between `start()` and `stop()`; the mic stays open
- * across presses until `close()`.
- *
- * @public
- */
-export declare function createPttRecorder(sampleRate?: number): PttRecorder;
-/**
- * Open the microphone and stream endpointed utterances into a sync session.
- *
- * @throws If microphone access is denied or worklet registration fails.
- */
-export declare function startSyncMicrophone(opts: SyncMicrophoneOptions): Promise<SyncMicrophone>;

package/dist/sync-session.d.ts

@@ -1,49 +0,0 @@
-/**
- * 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

@@ -1,54 +0,0 @@
-/**
- * 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;