@memberjunction/ai-realtime-client 0.0.1 → 5.41.0

package/dist/audio/pcmPlayback.d.ts

@@ -0,0 +1,73 @@
+import { IRealtimeAudioMeter } from './audioMeter.js';
+/**
+ * The playback contract for a client-owned realtime audio plane: schedules raw PCM16 chunks
+ * for gapless playout and reports whether audio is AUDIBLY playing. Production is
+ * {@link RealtimePcmPlayback} (Web Audio, playhead-clock scheduling); tests inject a fake with
+ * a controllable `IsPlaying`.
+ *
+ * Shared by every websocket driver whose audio plane is client-owned (Gemini Live, ElevenLabs
+ * Agents) — WebRTC drivers (OpenAI) get playback from the peer connection instead and don't
+ * use this.
+ */
+export interface IRealtimePcmPlayback {
+    /** Schedules a raw PCM16 mono chunk back-to-back after any already-queued audio. */
+    Enqueue(pcm16: ArrayBuffer): void;
+    /** Stops + clears every scheduled source (barge-in / interruption). */
+    Flush(): void;
+    /** `true` while scheduled audio is audibly playing (playhead ahead of the context clock). */
+    readonly IsPlaying: boolean;
+    /** Flushes and releases the underlying audio context. */
+    Close(): void;
+    /**
+     * OPTIONAL: creates an {@link IRealtimeAudioMeter} tapping this engine's output — the
+     * AGENT-audio side of the call UI's audio-reactive visuals. Drivers feed it to
+     * `BaseRealtimeClient`'s audio-activity surface. Optional so test fakes (and minimal
+     * implementations) stay valid; callers use `playback.CreateMeter?.() ?? null`.
+     */
+    CreateMeter?(): IRealtimeAudioMeter | null;
+}
+/**
+ * Web Audio playout scheduler for raw PCM16 model audio at a driver-supplied sample rate.
+ *
+ * Chunks are wrapped in `AudioBuffer`s and scheduled back-to-back against a **playhead clock**:
+ * each chunk starts at `max(playheadTime, currentTime)` and advances the playhead by its
+ * duration, producing gapless playout regardless of network jitter. {@link IsPlaying} is
+ * computed directly from that clock — the playhead being ahead of `currentTime` (with live
+ * sources) means audio is audibly coming out of the speaker. On interruption, {@link Flush}
+ * stops every scheduled source and rewinds the playhead.
+ *
+ * Generalized from the Gemini driver's original 24 kHz-fixed engine: the sample rate is now a
+ * constructor parameter so providers that negotiate their output format at session start
+ * (e.g. ElevenLabs' `agent_output_audio_format`) can construct the playout engine with the
+ * negotiated rate.
+ */
+export declare class RealtimePcmPlayback implements IRealtimePcmPlayback {
+    private context;
+    private sampleRate;
+    /**
+     * Master gain every source routes through (instead of the destination directly) —
+     * the single tap point {@link CreateMeter} analyses without altering the audio path.
+     */
+    private masterGain;
+    /** The absolute context time up to which audio has been scheduled. */
+    private playheadTime;
+    /** Sources scheduled and not yet ended (so Flush can stop them). */
+    private activeSources;
+    /**
+     * @param sampleRate The PCM16 sample rate (Hz) of the chunks this engine will play
+     *   (e.g. 24000 for Gemini Live, the negotiated `agent_output_audio_format` rate for
+     *   ElevenLabs).
+     */
+    constructor(sampleRate: number);
+    /** @inheritdoc */
+    Enqueue(pcm16: ArrayBuffer): void;
+    /** @inheritdoc */
+    Flush(): void;
+    /** @inheritdoc */
+    get IsPlaying(): boolean;
+    /** @inheritdoc */
+    CreateMeter(): IRealtimeAudioMeter | null;
+    /** @inheritdoc */
+    Close(): void;
+}
+//# sourceMappingURL=pcmPlayback.d.ts.map

package/dist/audio/pcmPlayback.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pcmPlayback.d.ts","sourceRoot":"","sources":["../../src/audio/pcmPlayback.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,mBAAmB,EAAsB,MAAM,cAAc,CAAC;AAEvE;;;;;;;;;GASG;AACH,MAAM,WAAW,oBAAoB;IACjC,oFAAoF;IACpF,OAAO,CAAC,KAAK,EAAE,WAAW,GAAG,IAAI,CAAC;IAClC,uEAAuE;IACvE,KAAK,IAAI,IAAI,CAAC;IACd,6FAA6F;IAC7F,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;IAC5B,yDAAyD;IACzD,KAAK,IAAI,IAAI,CAAC;IACd;;;;;OAKG;IACH,WAAW,CAAC,IAAI,mBAAmB,GAAG,IAAI,CAAC;CAC9C;AAED;;;;;;;;;;;;;;GAcG;AACH,qBAAa,mBAAoB,YAAW,oBAAoB;IAC5D,OAAO,CAAC,OAAO,CAAe;IAC9B,OAAO,CAAC,UAAU,CAAS;IAC3B;;;OAGG;IACH,OAAO,CAAC,UAAU,CAAW;IAC7B,sEAAsE;IACtE,OAAO,CAAC,YAAY,CAAK;IACzB,oEAAoE;IACpE,OAAO,CAAC,aAAa,CAAoC;IAEzD;;;;OAIG;gBACS,UAAU,EAAE,MAAM;IAO9B,kBAAkB;IACX,OAAO,CAAC,KAAK,EAAE,WAAW,GAAG,IAAI;IAiBxC,kBAAkB;IACX,KAAK,IAAI,IAAI;IAYpB,kBAAkB;IAClB,IAAW,SAAS,IAAI,OAAO,CAE9B;IAED,kBAAkB;IACX,WAAW,IAAI,mBAAmB,GAAG,IAAI;IAIhD,kBAAkB;IACX,KAAK,IAAI,IAAI;CAIvB"}

package/dist/audio/pcmPlayback.js

@@ -0,0 +1,78 @@
+import { pcm16ToFloat32 } from './pcmUtils.js';
+import { RealtimeAudioMeter } from './audioMeter.js';
+/**
+ * Web Audio playout scheduler for raw PCM16 model audio at a driver-supplied sample rate.
+ *
+ * Chunks are wrapped in `AudioBuffer`s and scheduled back-to-back against a **playhead clock**:
+ * each chunk starts at `max(playheadTime, currentTime)` and advances the playhead by its
+ * duration, producing gapless playout regardless of network jitter. {@link IsPlaying} is
+ * computed directly from that clock — the playhead being ahead of `currentTime` (with live
+ * sources) means audio is audibly coming out of the speaker. On interruption, {@link Flush}
+ * stops every scheduled source and rewinds the playhead.
+ *
+ * Generalized from the Gemini driver's original 24 kHz-fixed engine: the sample rate is now a
+ * constructor parameter so providers that negotiate their output format at session start
+ * (e.g. ElevenLabs' `agent_output_audio_format`) can construct the playout engine with the
+ * negotiated rate.
+ */
+export class RealtimePcmPlayback {
+    /**
+     * @param sampleRate The PCM16 sample rate (Hz) of the chunks this engine will play
+     *   (e.g. 24000 for Gemini Live, the negotiated `agent_output_audio_format` rate for
+     *   ElevenLabs).
+     */
+    constructor(sampleRate) {
+        /** The absolute context time up to which audio has been scheduled. */
+        this.playheadTime = 0;
+        /** Sources scheduled and not yet ended (so Flush can stop them). */
+        this.activeSources = new Set();
+        this.sampleRate = sampleRate;
+        this.context = new AudioContext({ sampleRate });
+        this.masterGain = this.context.createGain();
+        this.masterGain.connect(this.context.destination);
+    }
+    /** @inheritdoc */
+    Enqueue(pcm16) {
+        const samples = pcm16ToFloat32(pcm16);
+        if (samples.length === 0) {
+            return;
+        }
+        const buffer = this.context.createBuffer(1, samples.length, this.sampleRate);
+        buffer.copyToChannel(samples, 0);
+        const source = this.context.createBufferSource();
+        source.buffer = buffer;
+        source.connect(this.masterGain);
+        source.onended = () => this.activeSources.delete(source);
+        this.activeSources.add(source);
+        const startAt = Math.max(this.playheadTime, this.context.currentTime);
+        source.start(startAt);
+        this.playheadTime = startAt + buffer.duration;
+    }
+    /** @inheritdoc */
+    Flush() {
+        for (const source of this.activeSources) {
+            try {
+                source.stop();
+            }
+            catch {
+                /* source never started or already stopped — fine */
+            }
+        }
+        this.activeSources.clear();
+        this.playheadTime = 0;
+    }
+    /** @inheritdoc */
+    get IsPlaying() {
+        return this.activeSources.size > 0 && this.playheadTime > this.context.currentTime;
+    }
+    /** @inheritdoc */
+    CreateMeter() {
+        return RealtimeAudioMeter.ForContextNode(this.context, this.masterGain);
+    }
+    /** @inheritdoc */
+    Close() {
+        this.Flush();
+        void this.context.close();
+    }
+}
+//# sourceMappingURL=pcmPlayback.js.map

package/dist/audio/pcmPlayback.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pcmPlayback.js","sourceRoot":"","sources":["../../src/audio/pcmPlayback.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAC5C,OAAO,EAAuB,kBAAkB,EAAE,MAAM,cAAc,CAAC;AA8BvE;;;;;;;;;;;;;;GAcG;AACH,MAAM,OAAO,mBAAmB;IAa5B;;;;OAIG;IACH,YAAY,UAAkB;QAV9B,sEAAsE;QAC9D,iBAAY,GAAG,CAAC,CAAC;QACzB,oEAAoE;QAC5D,kBAAa,GAAG,IAAI,GAAG,EAAyB,CAAC;QAQrD,IAAI,CAAC,UAAU,GAAG,UAAU,CAAC;QAC7B,IAAI,CAAC,OAAO,GAAG,IAAI,YAAY,CAAC,EAAE,UAAU,EAAE,CAAC,CAAC;QAChD,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC,OAAO,CAAC,UAAU,EAAE,CAAC;QAC5C,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,WAAW,CAAC,CAAC;IACtD,CAAC;IAED,kBAAkB;IACX,OAAO,CAAC,KAAkB;QAC7B,MAAM,OAAO,GAAG,cAAc,CAAC,KAAK,CAAC,CAAC;QACtC,IAAI,OAAO,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YACvB,OAAO;QACX,CAAC;QACD,MAAM,MAAM,GAAG,IAAI,CAAC,OAAO,CAAC,YAAY,CAAC,CAAC,EAAE,OAAO,CAAC,MAAM,EAAE,IAAI,CAAC,UAAU,CAAC,CAAC;QAC7E,MAAM,CAAC,aAAa,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC;QACjC,MAAM,MAAM,GAAG,IAAI,CAAC,OAAO,CAAC,kBAAkB,EAAE,CAAC;QACjD,MAAM,CAAC,MAAM,GAAG,MAAM,CAAC;QACvB,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;QAChC,MAAM,CAAC,OAAO,GAAG,GAAG,EAAE,CAAC,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;QACzD,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;QAC/B,MAAM,OAAO,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,YAAY,EAAE,IAAI,CAAC,OAAO,CAAC,WAAW,CAAC,CAAC;QACtE,MAAM,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;QACtB,IAAI,CAAC,YAAY,GAAG,OAAO,GAAG,MAAM,CAAC,QAAQ,CAAC;IAClD,CAAC;IAED,kBAAkB;IACX,KAAK;QACR,KAAK,MAAM,MAAM,IAAI,IAAI,CAAC,aAAa,EAAE,CAAC;YACtC,IAAI,CAAC;gBACD,MAAM,CAAC,IAAI,EAAE,CAAC;YAClB,CAAC;YAAC,MAAM,CAAC;gBACL,oDAAoD;YACxD,CAAC;QACL,CAAC;QACD,IAAI,CAAC,aAAa,CAAC,KAAK,EAAE,CAAC;QAC3B,IAAI,CAAC,YAAY,GAAG,CAAC,CAAC;IAC1B,CAAC;IAED,kBAAkB;IAClB,IAAW,SAAS;QAChB,OAAO,IAAI,CAAC,aAAa,CAAC,IAAI,GAAG,CAAC,IAAI,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC,OAAO,CAAC,WAAW,CAAC;IACvF,CAAC;IAED,kBAAkB;IACX,WAAW;QACd,OAAO,kBAAkB,CAAC,cAAc,CAAC,IAAI,CAAC,OAAO,EAAE,IAAI,CAAC,UAAU,CAAC,CAAC;IAC5E,CAAC;IAED,kBAAkB;IACX,KAAK;QACR,IAAI,CAAC,KAAK,EAAE,CAAC;QACb,KAAK,IAAI,CAAC,OAAO,CAAC,KAAK,EAAE,CAAC;IAC9B,CAAC;CACJ"}

package/dist/audio/pcmUtils.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Shared base64 / PCM16 codec helpers for client-owned realtime audio planes.
+ *
+ * Extracted from the Gemini client driver so every websocket-based driver with a
+ * client-owned audio plane (Gemini Live, ElevenLabs Agents, future providers) shares one
+ * implementation. `atob`/`btoa` are global in both browsers and Node 18+, so these run
+ * unchanged in unit tests.
+ */
+/** Decodes a base64 string into a freshly-allocated `ArrayBuffer`. */
+export declare function base64ToArrayBuffer(base64: string): ArrayBuffer;
+/** Encodes raw bytes to base64 in chunks (avoids call-stack limits on large frames). */
+export declare function bytesToBase64(bytes: Uint8Array): string;
+/** Converts a Float32 [-1, 1] sample block to PCM16 little-endian bytes, base64-encoded. */
+export declare function encodeFloat32ToPcm16Base64(samples: Float32Array): string;
+/** Converts raw PCM16 little-endian bytes to Float32 samples (truncates a trailing odd byte). */
+export declare function pcm16ToFloat32(pcm: ArrayBuffer): Float32Array<ArrayBuffer>;
+//# sourceMappingURL=pcmUtils.d.ts.map

package/dist/audio/pcmUtils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pcmUtils.d.ts","sourceRoot":"","sources":["../../src/audio/pcmUtils.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,sEAAsE;AACtE,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,MAAM,GAAG,WAAW,CAO/D;AAED,wFAAwF;AACxF,wBAAgB,aAAa,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,CAOvD;AAED,4FAA4F;AAC5F,wBAAgB,0BAA0B,CAAC,OAAO,EAAE,YAAY,GAAG,MAAM,CAOxE;AAED,iGAAiG;AACjG,wBAAgB,cAAc,CAAC,GAAG,EAAE,WAAW,GAAG,YAAY,CAAC,WAAW,CAAC,CAQ1E"}

package/dist/audio/pcmUtils.js

@@ -0,0 +1,46 @@
+/**
+ * Shared base64 / PCM16 codec helpers for client-owned realtime audio planes.
+ *
+ * Extracted from the Gemini client driver so every websocket-based driver with a
+ * client-owned audio plane (Gemini Live, ElevenLabs Agents, future providers) shares one
+ * implementation. `atob`/`btoa` are global in both browsers and Node 18+, so these run
+ * unchanged in unit tests.
+ */
+/** Decodes a base64 string into a freshly-allocated `ArrayBuffer`. */
+export function base64ToArrayBuffer(base64) {
+    const binary = atob(base64);
+    const out = new Uint8Array(binary.length);
+    for (let i = 0; i < binary.length; i++) {
+        out[i] = binary.charCodeAt(i);
+    }
+    return out.buffer;
+}
+/** Encodes raw bytes to base64 in chunks (avoids call-stack limits on large frames). */
+export function bytesToBase64(bytes) {
+    let binary = '';
+    const chunkSize = 0x8000;
+    for (let i = 0; i < bytes.length; i += chunkSize) {
+        binary += String.fromCharCode(...bytes.subarray(i, i + chunkSize));
+    }
+    return btoa(binary);
+}
+/** Converts a Float32 [-1, 1] sample block to PCM16 little-endian bytes, base64-encoded. */
+export function encodeFloat32ToPcm16Base64(samples) {
+    const pcm = new Int16Array(samples.length);
+    for (let i = 0; i < samples.length; i++) {
+        const s = Math.max(-1, Math.min(1, samples[i]));
+        pcm[i] = s < 0 ? s * 0x8000 : s * 0x7fff;
+    }
+    return bytesToBase64(new Uint8Array(pcm.buffer));
+}
+/** Converts raw PCM16 little-endian bytes to Float32 samples (truncates a trailing odd byte). */
+export function pcm16ToFloat32(pcm) {
+    const even = pcm.byteLength - (pcm.byteLength % 2);
+    const ints = new Int16Array(pcm.slice(0, even));
+    const out = new Float32Array(ints.length);
+    for (let i = 0; i < ints.length; i++) {
+        out[i] = ints[i] / 0x8000;
+    }
+    return out;
+}
+//# sourceMappingURL=pcmUtils.js.map

package/dist/audio/pcmUtils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pcmUtils.js","sourceRoot":"","sources":["../../src/audio/pcmUtils.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,sEAAsE;AACtE,MAAM,UAAU,mBAAmB,CAAC,MAAc;IAC9C,MAAM,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC,CAAC;IAC5B,MAAM,GAAG,GAAG,IAAI,UAAU,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;IAC1C,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;QACrC,GAAG,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC;IAClC,CAAC;IACD,OAAO,GAAG,CAAC,MAAM,CAAC;AACtB,CAAC;AAED,wFAAwF;AACxF,MAAM,UAAU,aAAa,CAAC,KAAiB;IAC3C,IAAI,MAAM,GAAG,EAAE,CAAC;IAChB,MAAM,SAAS,GAAG,MAAM,CAAC;IACzB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC,IAAI,SAAS,EAAE,CAAC;QAC/C,MAAM,IAAI,MAAM,CAAC,YAAY,CAAC,GAAG,KAAK,CAAC,QAAQ,CAAC,CAAC,EAAE,CAAC,GAAG,SAAS,CAAC,CAAC,CAAC;IACvE,CAAC;IACD,OAAO,IAAI,CAAC,MAAM,CAAC,CAAC;AACxB,CAAC;AAED,4FAA4F;AAC5F,MAAM,UAAU,0BAA0B,CAAC,OAAqB;IAC5D,MAAM,GAAG,GAAG,IAAI,UAAU,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;IAC3C,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;QACtC,MAAM,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QAChD,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC;IAC7C,CAAC;IACD,OAAO,aAAa,CAAC,IAAI,UAAU,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC;AACrD,CAAC;AAED,iGAAiG;AACjG,MAAM,UAAU,cAAc,CAAC,GAAgB;IAC3C,MAAM,IAAI,GAAG,GAAG,CAAC,UAAU,GAAG,CAAC,GAAG,CAAC,UAAU,GAAG,CAAC,CAAC,CAAC;IACnD,MAAM,IAAI,GAAG,IAAI,UAAU,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,CAAC;IAChD,MAAM,GAAG,GAAG,IAAI,YAAY,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;IAC1C,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;QACnC,GAAG,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC;IAC9B,CAAC;IACD,OAAO,GAAG,CAAC;AACf,CAAC"}

package/dist/drivers/assemblyAIRealtimeClient.d.ts

@@ -0,0 +1,384 @@
+import { ClientRealtimeSessionConfig, JSONObject } from '@memberjunction/ai';
+import { BaseRealtimeClient } from '../generic/baseRealtimeClient.js';
+import { IRealtimePcmPlayback } from '../audio/pcmPlayback.js';
+import { IPcmMicCapture } from '../audio/micCapture.js';
+/** The single Voice Agent websocket endpoint (auth rides as a `?token=` query parameter). */
+export declare const ASSEMBLYAI_AGENT_WS_URL = "wss://agents.assemblyai.com/v1/ws";
+/**
+ * The Voice Agent wire format is FIXED: 16-bit signed little-endian PCM, mono, 24 kHz,
+ * base64-encoded, in BOTH directions (`input.audio` up, `reply.audio` down) — no
+ * per-session format negotiation exists on this provider.
+ */
+export declare const ASSEMBLYAI_PCM_SAMPLE_RATE = 24000;
+/** A parsed inbound websocket frame. The Voice Agent protocol multiplexes on `type`. */
+export interface AssemblyAIServerEvent {
+    type?: string;
+    /** `session.ready` — the provider-assigned session id. */
+    session_id?: string;
+    /** `transcript.user[.delta]` / `transcript.agent` — the transcribed text. */
+    text?: string;
+    /** `transcript.*` — provider conversation-item id. */
+    item_id?: string;
+    /** `reply.started` / `transcript.agent` — id of the reply the frame belongs to. */
+    reply_id?: string;
+    /** `transcript.agent` — true when the turn was cut off by a barge-in. */
+    interrupted?: boolean;
+    /** `reply.audio` — one base64 PCM16 chunk of the agent's spoken output. */
+    data?: string;
+    /** `reply.done` — `'interrupted'` when the user barged in mid-reply; absent otherwise. */
+    status?: string;
+    /** `tool.call` — correlation id the result must echo. */
+    call_id?: string;
+    /** `tool.call` — the tool name. */
+    name?: string;
+    /** `tool.call` — the arguments, ALREADY PARSED into an object by the provider. */
+    arguments?: JSONObject;
+    /** `session.error` — provider error code. */
+    code?: string;
+    /** `session.error` — human-readable error message. */
+    message?: string;
+    /** `session.error` — the offending parameter, when applicable. */
+    param?: string;
+    /** `session.updated` — echo of the applied session object. */
+    session?: JSONObject;
+    /** `session.ended` — total billable session seconds. */
+    session_duration_seconds?: number;
+}
+/**
+ * The minimal websocket surface this client depends on: assignable lifecycle handlers plus
+ * `send`/`close`. Declaring the seam as an interface (rather than the platform `WebSocket`)
+ * lets unit tests inject a fully in-memory fake that captures outbound frames and drives the
+ * handlers with AssemblyAI-shaped events — no websocket, no network.
+ */
+export interface IAssemblyAIClientSocket {
+    /** Invoked once the socket is open. */
+    onopen: (() => void) | null;
+    /** Invoked with each inbound frame's raw string payload. */
+    onmessage: ((data: string) => void) | null;
+    /** Invoked on a socket-level error (fatal). */
+    onerror: ((message: string) => void) | null;
+    /** Invoked when the socket closes (any reason). */
+    onclose: (() => void) | null;
+    /** Sends one JSON-serialized client frame. */
+    send(data: string): void;
+    /** Terminates the underlying connection. */
+    close(): void;
+}
+/**
+ * AssemblyAI Voice Agent implementation of {@link BaseRealtimeClient}: a **browser-direct**
+ * agent websocket authenticated with the server-minted ONE-TIME client token (the
+ * `EphemeralToken` — no API key ever reaches the browser).
+ *
+ * Registered with the ClassFactory under the key `'assemblyai'` — the `Provider` string the
+ * server's `AssemblyAIRealtime` driver stamps on its `ClientRealtimeSessionConfig`.
+ *
+ * Owns ALL AssemblyAI wire concerns (the behavioral sibling of the ElevenLabs client driver —
+ * the audio plane is client-owned over a websocket, no WebRTC):
+ * - **Connect handshake**: open `wss://…/v1/ws?token=…` → send the server-authored
+ *   `session.update` (from the `SessionConfig` pact: system prompt, tools, voice, turn
+ *   detection) as the FIRST frame → wait for `session.ready` → build the audio plane at the
+ *   provider's FIXED 24 kHz PCM16 format → `'listening'`. The state is gated on
+ *   `session.ready` (driver obligation #7): only then has the provider confirmed the session
+ *   config is applied (audio sent earlier would be dropped anyway).
+ * - **Audio in**: mic PCM16 at 24 kHz via the shared {@link createPcmMicCapture} worklet
+ *   pipeline, streamed as base64 `input.audio` frames.
+ * - **Audio out**: `reply.audio` chunks decoded into the shared {@link RealtimePcmPlayback}
+ *   at 24 kHz; {@link IsAudioPlaying} comes from its playout clock.
+ * - **Transcripts**: user turns stream as `transcript.user.delta` fragments
+ *   (`IsFinal: false` deltas) finalized by `transcript.user`; agent turns arrive as ONE
+ *   final `transcript.agent` (after a barge-in it carries `interrupted: true` and the text
+ *   already reflects the truncated turn — no ElevenLabs-style correction event follows).
+ * - **Busy mapping**: `IsBusy` is set on `reply.started` / first `reply.audio` (and eagerly
+ *   when this client triggers a reply) and cleared on `reply.done` and on a `tool.call`
+ *   frame (the agent has yielded the floor pending the result — deadlock guard,
+ *   obligation #2).
+ * - **Narration is NATIVE**: {@link RequestSpokenUpdate} sends `reply.create` with the
+ *   instructions (a real per-response-instructions channel — no user-turn emulation). The
+ *   response kind is stamped `'narration'` at send time (sends are the turn triggers) and
+ *   reset on the reply boundary; the kind tagging assumes `transcript.agent` precedes its
+ *   `reply.done`, which is the provider's emission order.
+ * - **{@link SendText} is EMULATED via `reply.create`**: the protocol accepts no typed user
+ *   input, so the typed text rides as response instructions framing it as the user's turn.
+ *   Fidelity caveat: the text enters as instructions rather than a conversation user turn,
+ *   so the agent may occasionally reference "the message you sent" — hosts should treat
+ *   typed input on this provider as best-effort.
+ * - **{@link SendContextNote} is EMULATED via the mutable `system_prompt`**: notes are
+ *   appended under a "Background updates" heading and the full prompt is re-sent via
+ *   `session.update` — a config write that never triggers or disturbs generation, so it is
+ *   sent immediately even mid-reply.
+ * - **Barge-in**: `input.speech.started` while a reply is active (or audio audibly playing)
+ *   is the snappy flush point (per the provider's own guidance — ~300 ms faster than waiting
+ *   for `reply.done`); `reply.done` with `status: 'interrupted'` is the authoritative
+ *   verdict and is the fallback flush when the speech-start gate missed. A speech start
+ *   while idle is a user simply taking their turn — NOT an interruption (base contract).
+ * - **Cancel**: the protocol has no cancel frame. {@link CancelActiveResponse} flushes the
+ *   locally-owned playout queue (speech stops immediately), marks the reply inactive, and
+ *   SUPPRESSES residual `reply.audio` frames of the cancelled reply until the next reply
+ *   boundary — so late-arriving chunks of a cancelled turn are never played or allowed to
+ *   re-assert `'speaking'`.
+ * - **No usage telemetry**: the streaming socket exposes no token-usage events, so this
+ *   driver NEVER emits {@link OnUsage} (registering a handler is safe; it just never fires).
+ */
+export declare class AssemblyAIRealtimeClient extends BaseRealtimeClient {
+    private socket;
+    private micStream;
+    private micCapture;
+    private playback;
+    /** True while an agent reply is in flight; gates (queues) client-triggered sends. */
+    private responseActive;
+    /** The kind of the reply currently in flight; stamped at send time, reset on boundary. */
+    private activeResponseKind;
+    /** Sends deferred while a reply is in flight; drained in order at the next boundary. */
+    private queuedSends;
+    /**
+     * True between a {@link CancelActiveResponse} and the next reply boundary: residual
+     * `reply.audio` chunks of the cancelled reply are dropped instead of played.
+     */
+    private suppressReplyAudio;
+    /**
+     * Tool calls awaiting their result — used to make {@link SendToolResult} EXACTLY-ONCE:
+     * the id is consumed when the result is accepted (queued or sent), so a duplicate send
+     * for the same call is dropped with a warning instead of confusing the conversation.
+     */
+    private pendingToolCallIds;
+    /** True once Disconnect ran — an expected socket close must not surface as fatal. */
+    private closedByConsumer;
+    /** Provider-assigned session id (from `session.ready`) — the `session.resume` key. */
+    private providerSessionId;
+    /** The token-authenticated endpoint URL, kept for the resume reattach socket. */
+    private connectUrl;
+    /** One resume attempt per session: a second unexpected drop is fatal (as before). */
+    private resumeAttempted;
+    /**
+     * The client's own view of the session state — mirrors what was last emitted, EXCEPT after
+     * a tool call: the host typically shows its own busy indicator then, so the client silently
+     * leaves `'speaking'` (no emission) until the result reply's first output re-asserts it.
+     */
+    private currentState;
+    /** The server-authored base system prompt (from the SessionConfig pact). */
+    private basePrompt;
+    /** Accumulated {@link SendContextNote} texts, re-sent with the full prompt each time. */
+    private contextNotes;
+    /**
+     * Opens the client-direct session: socket to the token-authenticated endpoint, the
+     * server-authored `session.update` as the first frame, then — once `session.ready`
+     * confirms the config is applied — the audio plane at the provider's fixed 24 kHz
+     * format. Reports `'listening'` only after all of that (obligation #7).
+     */
+    Connect(config: ClientRealtimeSessionConfig, micStream: MediaStream): Promise<void>;
+    /**
+     * Tears down the socket, mic capture, mic tracks, and playout engine, resets the response
+     * state machine, and emits a final `'closed'` (unless already `'error'`). Sends
+     * `session.end` first — without it the provider holds the session (billable) for a
+     * 30-second resume window. Safe to call more than once.
+     */
+    Disconnect(): Promise<void>;
+    /**
+     * Injects typed text — EMULATED via `reply.create` (the protocol accepts no typed user
+     * input), with instructions framing the text as the user's turn. No-op when the session
+     * is not open. See the class-level fidelity caveat.
+     *
+     * **SendText implies barge-in** (base-contract rule): an active spoken reply is cancelled
+     * via {@link CancelActiveResponse} first — playback flushed, reply marked inactive,
+     * queued sends drained — so the typed turn takes the floor immediately. If a drained
+     * queued send starts a new reply, the text queues behind it, preserving delivery order.
+     */
+    SendText(text: string): void;
+    /**
+     * @inheritdoc
+     *
+     * AssemblyAI has no cancel frame — the client OWNS the audio plane, so cancelling means:
+     * flush the local playout queue (speech stops immediately), mark the in-flight reply
+     * inactive, SUPPRESS residual `reply.audio` chunks of the cancelled reply until the next
+     * reply boundary, and drain queued sends (a queued narration takes the floor next —
+     * delivery is never dropped by a cancel). No-op when nothing is active.
+     */
+    CancelActiveResponse(): void;
+    /**
+     * Injects background context — EMULATED via the mutable `system_prompt`: the note is
+     * appended under a "Background updates" heading and the FULL prompt is re-sent via
+     * `session.update`. A config write never triggers or disturbs generation, so it is sent
+     * immediately even while a reply is in flight (no queueing applies).
+     */
+    SendContextNote(text: string): void;
+    /**
+     * Triggers ONE short spoken update — NATIVE via `reply.create` with per-response
+     * instructions. The resulting reply is stamped `Kind: 'narration'` at send time (reset
+     * on the reply boundary). Queued behind any in-flight reply per the base contract's
+     * collision rule (an overlapping `reply.create` would collide with active generation).
+     */
+    RequestSpokenUpdate(instructions: string): void;
+    /**
+     * Feeds an executed tool's result back via `tool.result`, correlated by the provider's
+     * `call_id`. EXACTLY-ONCE: the pending id is consumed when the result is accepted, and a
+     * duplicate (or unknown) callID is dropped with a warning. Sent immediately when idle —
+     * the provider speaks the result as the turn's continuation (no explicit generation
+     * trigger exists or is needed) — otherwise queued behind the in-flight reply (e.g. a
+     * progress narration) so the trigger is never lost and the narration's kind tagging is
+     * not clobbered. The wire `result` slot expects a JSON-STRING, which is exactly the
+     * contract's `outputJson` shape — it passes through verbatim.
+     */
+    SendToolResult(callID: string, outputJson: string): void;
+    /**
+     * Mutes / unmutes by toggling the mic tracks' `enabled` flag: the capture pipeline stays
+     * up and streams SILENCE while muted (the provider's VAD sees a continuous stream and the
+     * un-mute is glitch-free — same policy as the other client drivers).
+     */
+    SetMuted(muted: boolean): void;
+    /** @inheritdoc */
+    get IsBusy(): boolean;
+    /**
+     * @inheritdoc
+     *
+     * Computed directly from the playout engine's playhead clock — this client OWNS the
+     * output buffer, so "audibly playing" is precisely "scheduled audio extends beyond the
+     * audio context's current time".
+     */
+    get IsAudioPlaying(): boolean;
+    /**
+     * Creation seam for the agent websocket. Production wraps the platform-global
+     * `WebSocket` opened against the token-authenticated URL; unit tests override this to
+     * return an in-memory fake. Handlers are attached by {@link Connect} AFTER this returns,
+     * so the implementation must not require them at construction time.
+     */
+    protected createSocket(url: string): IAssemblyAIClientSocket;
+    /**
+     * Creation seam for the mic-capture pipeline at the provider's fixed 24 kHz rate.
+     * Production delegates to the shared {@link createPcmMicCapture}; unit tests override
+     * this with a no-op fake (and may capture `onPcmChunk` to simulate mic frames).
+     */
+    protected createMicCapture(micStream: MediaStream, sampleRate: number, onPcmChunk: (base64Pcm16: string) => void): Promise<IPcmMicCapture>;
+    /**
+     * Creation seam for the playout engine at the provider's fixed 24 kHz rate. Production
+     * returns the shared {@link RealtimePcmPlayback}.
+     */
+    protected createPlayback(sampleRate: number): IRealtimePcmPlayback;
+    /** Resolver for the in-flight Connect's session.ready wait (null outside Connect). */
+    private onSessionReady;
+    /**
+     * Extracts the wire-shaped `session` object from the server-minted `SessionConfig` pact
+     * (`{ session, config }` — authored by the server's `AssemblyAIRealtime`). Falls back to
+     * an empty object when absent (the session then runs on provider defaults).
+     */
+    private parseSessionObject;
+    /** Streams one base64 PCM16 mic chunk as an `input.audio` frame. */
+    private sendMicChunk;
+    /** Surfaces a fatal socket error and marks the session unusable (obligation #6). */
+    private handleSocketError;
+    /**
+     * A socket close the CONSUMER didn't ask for is fatal: the provider hard-closes at token
+     * expiry and when it ends the session itself, so an unexpected close is how credential /
+     * session death reaches the host (obligation #6).
+     */
+    private handleSocketClose;
+    /**
+     * ONE-shot reattach inside the provider's 30-second resume window: a fresh socket to
+     * the same token-authenticated endpoint whose FIRST frame is `session.resume` with the
+     * `session_id` captured from `session.ready`. The provider re-confirms with another
+     * `session.ready`, which restores `'listening'` — the mic worklet and playout engine
+     * survive untouched (mic chunks simply flow into the new socket). A failed or second
+     * drop falls through to the pre-existing fatal path, so the worst case is exactly the
+     * old behavior. Returns `true` when a reattach was started.
+     */
+    private tryResumeSession;
+    /** Parses one raw socket payload; non-JSON frames are ignored. */
+    private handleSocketMessage;
+    /** Multiplexes one inbound frame to the focused per-concern handlers. */
+    private handleServerEvent;
+    /** A fresh reply is generating: lift any cancel suppression and mark the agent busy. */
+    private handleReplyStarted;
+    /**
+     * Decodes one base64 reply-audio chunk into the playout queue and marks generation live —
+     * unless a local cancel suppressed the remainder of this reply, in which case the chunk
+     * is dropped (never played, never re-asserts `'speaking'`).
+     */
+    private handleReplyAudio;
+    /** User transcript: streaming deltas (`IsFinal: false`) finalized by `transcript.user`. */
+    private handleUserTranscript;
+    /**
+     * Agent transcript: the turn's complete text, emitted FINAL with the ACTIVE reply kind
+     * so narration turns are tagged correctly (stamp-at-send — see the class doc). After a
+     * barge-in the provider sends the truncated text with `interrupted: true` — already the
+     * authoritative record of what was spoken, emitted the same way.
+     */
+    private handleAgentTranscript;
+    /**
+     * Reply boundary. `status: 'interrupted'` is the provider's authoritative true-barge-in
+     * verdict — when the snappy `input.speech.started` gate already handled it this is a
+     * no-op fallback; when it didn't (e.g. the speech-start frame was missed), the flush +
+     * interruption surface here. Then: release the busy lock, lift any cancel suppression,
+     * reset the reply kind, drain queued sends (stopping at the first one that starts a new
+     * reply), and return the floor.
+     */
+    private handleReplyDone;
+    /**
+     * Surfaces the agent's tool call to the host. Two deliberate behaviors mirror the other
+     * drivers: (1) the client silently leaves `'speaking'` (no emission) so a host-rendered
+     * busy indicator isn't clobbered by the turn's trailing frames (obligation #1); (2)
+     * `responseActive` is CLEARED — the agent has yielded the floor pending the result, so a
+     * queued send can never deadlock (obligation #2). The queue is NOT drained here: a queued
+     * narration must not trigger a reply between the tool call and its result. The provider
+     * emits `arguments` ALREADY PARSED, so it is re-stringified to honor the base contract's
+     * JSON-string `ArgumentsJson` shape.
+     */
+    private handleToolCall;
+    /**
+     * The user started speaking. When a reply is in flight or audio is audibly playing this
+     * is a TRUE barge-in: flush playout NOW (the provider's own guidance — ~300 ms snappier
+     * than waiting for `reply.done`), suppress the cancelled reply's residual audio, surface
+     * the interruption, and give the floor back. While idle it is a user simply taking their
+     * turn — NOT an interruption (base contract), so nothing is emitted. The queue is NOT
+     * drained — the user has the floor; queued sends flush at the next reply boundary.
+     */
+    private handleSpeechStarted;
+    /**
+     * The provider ended the session itself. After a consumer {@link Disconnect} (which
+     * sends `session.end`) this is the expected acknowledgment and stays silent; otherwise
+     * it is surfaced as FATAL so the host tears down instead of idling on a dying socket.
+     */
+    private handleSessionEnded;
+    /**
+     * First model output of a reply (reply.started or an audio chunk): the agent is busy and
+     * the client is audibly / imminently `'speaking'`.
+     */
+    private markGenerationStarted;
+    /**
+     * Runs a send immediately when no reply is in flight; otherwise queues it for the next
+     * boundary (`reply.done`). An overlapping `reply.create` would collide with active
+     * generation, so deferral is the safe default — mirroring the other drivers' rule.
+     */
+    private enqueueOrRun;
+    /**
+     * Drains queued sends in order at a reply boundary, stopping as soon as one starts a
+     * new reply (sets {@link responseActive}) — the rest wait for that reply to finish.
+     */
+    private flushQueuedSends;
+    /**
+     * Sends a `reply.create` that triggers a reply, stamping the upcoming reply's kind at
+     * send time and eagerly marking the agent busy. `emitSpeaking` mirrors the other
+     * drivers: typed text reflects `'speaking'` immediately; narration waits for the first
+     * model output.
+     */
+    private sendReplyCreate;
+    /**
+     * Sends the `tool.result` frame (the provider speaks the result as the turn's
+     * continuation — no explicit generation trigger exists or is needed) and eagerly marks
+     * the agent busy so a queued narration can't slip in before the spoken result.
+     */
+    private sendToolResultFrame;
+    /** The base prompt plus every accumulated context note under a "Background updates" heading. */
+    private composePromptWithNotes;
+    /** JSON-serializes and sends one client frame (no-op once the socket is gone). */
+    private sendFrame;
+    /** Resets the per-session response state machine (used on Disconnect). */
+    private resetResponseState;
+    /** Updates the client's own state view and emits the change to the host. */
+    private setState;
+}
+/**
+ * Tree-shaking prevention: bundlers cannot see that {@link AssemblyAIRealtimeClient} is
+ * instantiated dynamically through the ClassFactory, so a consumer must call this no-op
+ * to create a static code path that keeps the `@RegisterClass` side effect alive.
+ */
+export declare function LoadAssemblyAIRealtimeClient(): void;
+//# sourceMappingURL=assemblyAIRealtimeClient.d.ts.map

package/dist/drivers/assemblyAIRealtimeClient.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"assemblyAIRealtimeClient.d.ts","sourceRoot":"","sources":["../../src/drivers/assemblyAIRealtimeClient.ts"],"names":[],"mappings":"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"}