@chanl/widget-sdk 0.2.0-canary.0

package/dist/voice/voice-client.js

@@ -0,0 +1,1187 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VoiceClient = void 0;
+const eventemitter3_1 = require("eventemitter3");
+const types_1 = require("./types");
+const websocket_1 = require("./transports/websocket");
+const webrtc_1 = require("./transports/webrtc");
+const vapi_1 = require("./transports/vapi");
+class VoiceClient extends eventemitter3_1.EventEmitter {
+    constructor(publicKey, config = {}) {
+        super();
+        this.log = {
+            log: console.debug.bind(console),
+            info: console.info.bind(console),
+            debug: console.debug.bind(console),
+            warn: console.warn.bind(console),
+            error: console.error.bind(console),
+        };
+        // =========================
+        // 2. Connection State & Status
+        // =========================
+        this.state = types_1.AudialState.Idle;
+        /**
+         * Active transport — WebSocket or WebRTC.
+         * Created on start(), destroyed on stop().
+         */
+        this.transport = null;
+        /**
+         * Which transport is actually in use for the current call.
+         */
+        this.activeTransportType = null;
+        /**
+         * Room connection state
+         */
+        this.roomState = null;
+        /**
+         * The current node ID
+         */
+        this.currentNodeId = null;
+        // =========================
+        // 3. Audio State (tracked by Audial, delegated to transport)
+        // =========================
+        this.audioDeafened = false;
+        this.micMuted = false;
+        // =========================
+        // 4. Retry & Reconnection Logic
+        // =========================
+        this.retryPolicy = { maxRetries: 3, backoffMs: 1000 };
+        this.retryCount = 0;
+        this.reconnectTimer = null;
+        this.connectionTimeoutTimer = null;
+        // Per-call-intent Idempotency-Key (IETF draft + Stripe pattern).
+        // Generated on user-initiated start, reused across retries within the
+        // same intent, cleared on successful connection (call is now
+        // "consumed") or on stop (next start is a new intent).
+        // Persisted to sessionStorage so a reload in the same tab during a
+        // pending connect reuses the same key → server returns the existing
+        // queued interaction instead of leaking a new one.
+        this.idempotencyKey = null;
+        // =========================
+        // 6. Chat Session State
+        // =========================
+        this.chatState = types_1.ChatState.Idle;
+        this.chatSession = null;
+        this.chatMessages = [];
+        this.publicKey = publicKey;
+        this.config = {
+            baseUrl: this.getBaseUrl(),
+            debug: true, // TODO URGENT: TESTING ONLY
+            initialMuted: false,
+            // autoReconnect defaults to FALSE. The old default of true produced
+            // zombie interactions: every retry calls start() → createRoom() which
+            // hits POST /interactions/websocket and creates a brand-new
+            // interaction. A transient WebRTC blip could leave 10+ "queued"
+            // interactions in the DB, none of which ever connected or produced
+            // a transcript. Users opting into reconnect must set it explicitly.
+            autoReconnect: false,
+            ...config
+        };
+        // Validate: authToken requires workspaceId
+        if (this.config.authToken && !this.config.workspaceId) {
+            throw new Error('Audial: workspaceId is required when using authToken');
+        }
+        if (this.config.debug) {
+            const authMode = this.config.authToken ? 'jwt' : 'publicKey';
+            console.debug("🎤 Audial SDK initialized:", {
+                authMode,
+                publicKey: this.publicKey ? this.publicKey.substring(0, 10) + "..." : '(none)',
+                baseUrl: this.config.baseUrl,
+                transport: this.config.transport ?? 'auto',
+            });
+        }
+        this.audioDeafened = this.config.initialMuted;
+    }
+    // ── Auth helpers (unchanged) ───────────────────────────────────────────
+    getAuthHeaders() {
+        if (this.config.authToken) {
+            const headers = {
+                'Authorization': `Bearer ${this.config.authToken}`,
+            };
+            if (this.config.workspaceId) {
+                headers['x-workspace-id'] = this.config.workspaceId;
+            }
+            return headers;
+        }
+        return {};
+    }
+    applyPublicKeyAuth(url) {
+        if (!this.config.authToken && this.publicKey) {
+            url.searchParams.set('publicKey', this.publicKey);
+        }
+    }
+    start(agentIdOrPayload, overrides) {
+        if (this.state !== types_1.AudialState.Idle) {
+            throw new Error("Audial: call already active");
+        }
+        this.currentNodeId = null;
+        let payload;
+        if (typeof agentIdOrPayload === 'string') {
+            payload = { agentId: agentIdOrPayload };
+        }
+        else {
+            payload = agentIdOrPayload;
+        }
+        this.state = types_1.AudialState.CreatingRoom;
+        this.retryCount = 0;
+        this.lastCallPayload = payload;
+        this.lastOverrides = overrides;
+        // Mint or restore the Idempotency-Key for this call intent.
+        // Same key is reused on every retry path inside this call attempt —
+        // the server dedups against it, so a retry loop can't leak zombie
+        // interactions. Cleared in stop() and on successful connection.
+        if (!this.idempotencyKey) {
+            this.idempotencyKey = this.restoreOrMintIdempotencyKey();
+        }
+        // Connection timeout — if 'ready' not received within limit, emit error
+        if (this.connectionTimeoutTimer) {
+            clearTimeout(this.connectionTimeoutTimer);
+        }
+        const timeoutMs = this.config.connectionTimeoutMs ?? 30000;
+        this.connectionTimeoutTimer = setTimeout(() => {
+            this.connectionTimeoutTimer = null;
+            this.emit('error', new Error('Connection timeout - voice service did not respond'));
+            this.stop(4000, 'connection-timeout');
+        }, timeoutMs);
+        if (this.config.debug) {
+            console.debug('🎤 Starting call:', { payload, overrides, timeoutMs });
+        }
+        this.createRoomAndConnect(payload, overrides);
+    }
+    /**
+     * Minimal description of a real-time session result returned by a
+     * `createSession` function. Mirrors the shape of `RealtimeSessionResult`
+     * from `@chanl/sdk` so consumers can pass `sdk.realtime.createSession`'s
+     * return value (after unwrapping `{ data }`) directly, without importing
+     * that type here (which would create a cross-package dependency).
+     *
+     * Only the fields needed for wiring are required; everything else is optional
+     * so this interface is forward-compatible as new credential types are added.
+     */
+    /**
+     * High-level orchestration method: fetch a provider session via an injected
+     * `createSession` function, then wire the credential into `connectProviderSession`.
+     *
+     * This keeps widget-sdk free of a dependency on `@chanl/sdk`. The consumer
+     * (e.g. chanl-admin) injects `sdk.realtime.createSession` as a plain function.
+     *
+     * Phase 1 only supports `credentialType === 'join-url'` (VAPI Daily rooms).
+     * Attempting to start a session with `token` or `ws-url` credentials will
+     * throw immediately with a clear "not yet supported" message.
+     *
+     * @param createSession - Async function that, given an agentId, resolves with
+     *   a session result containing `{ provider, credentialType, joinUrl?, ... }`.
+     * @param agentId - The agent ID to pass to `createSession`.
+     * @param opts.overrides - Optional assistant overrides forwarded to the transport.
+     *
+     * @throws Error if credentialType is not 'join-url' (Phase 1 only).
+     * @throws Error if a call is already active.
+     * @throws Error (async, via 'error' event) if the transport connect fails.
+     */
+    async startProviderSession(createSession, agentId, opts) {
+        if (this.state !== types_1.AudialState.Idle) {
+            throw new Error('Audial: call already active');
+        }
+        if (this.config.debug) {
+            console.debug('🎤 startProviderSession: fetching session for agent', agentId);
+        }
+        const session = await createSession(agentId);
+        if (session.credentialType !== 'join-url') {
+            throw new Error(`Audial: credentialType "${session.credentialType}" is not yet supported in Phase 1 — only 'join-url' is implemented`);
+        }
+        if (!session.joinUrl) {
+            throw new Error('Audial: createSession returned credentialType "join-url" but joinUrl is missing');
+        }
+        // Delegate to connectProviderSession which manages state transitions,
+        // timeout, and transport instantiation — no duplication.
+        this.connectProviderSession({
+            provider: session.provider,
+            joinUrl: session.joinUrl,
+            overrides: opts?.overrides,
+        });
+    }
+    /**
+     * Connect to a provider-managed voice session via a direct join URL.
+     *
+     * Unlike `start()`, this method does NOT call POST /interactions/websocket
+     * to create a room. Instead it instantiates the appropriate provider
+     * transport (currently only 'vapi' is supported) and connects directly
+     * to the provider's session URL (e.g. a VAPI Daily.co web-call URL).
+     *
+     * The public event API (ready, closed, transcript, speech-start, etc.)
+     * is identical to the room-based flow.
+     *
+     * @param params.provider - Provider identifier. Currently supports 'vapi'.
+     * @param params.joinUrl  - The provider's session join URL.
+     * @param params.overrides - Optional assistant overrides forwarded to the transport.
+     *
+     * @throws Error if provider is unsupported or if already in an active call.
+     */
+    connectProviderSession({ provider, joinUrl, overrides, }) {
+        if (this.state !== types_1.AudialState.Idle) {
+            throw new Error('Audial: call already active');
+        }
+        if (provider !== 'vapi') {
+            throw new Error(`Audial: unsupported provider "${provider}" — only 'vapi' is supported`);
+        }
+        if (!joinUrl) {
+            throw new Error('Audial: joinUrl is required for provider sessions');
+        }
+        this.state = types_1.AudialState.Connecting;
+        this.currentNodeId = null;
+        // Connection timeout — mirrors the room-based flow
+        if (this.connectionTimeoutTimer) {
+            clearTimeout(this.connectionTimeoutTimer);
+        }
+        const timeoutMs = this.config.connectionTimeoutMs ?? 30000;
+        this.connectionTimeoutTimer = setTimeout(() => {
+            this.connectionTimeoutTimer = null;
+            this.emit('error', new Error('Connection timeout - provider session did not respond'));
+            this.stop(4000, 'connection-timeout');
+        }, timeoutMs);
+        if (this.config.debug) {
+            console.debug('🎤 Connecting provider session:', { provider, joinUrl, timeoutMs });
+        }
+        this._connectVapiProviderSession(joinUrl, overrides);
+    }
+    /**
+     * Internal async implementation of connectProviderSession.
+     * Separated so the public method can remain synchronous (matching start()).
+     */
+    async _connectVapiProviderSession(joinUrl, overrides) {
+        try {
+            const callbacks = this.createTransportCallbacks();
+            this.transport = new vapi_1.VapiTransport(callbacks);
+            this.activeTransportType = 'vapi';
+            if (this.config.debug) {
+                console.debug('🚀 Using vapi transport for provider session');
+            }
+            await this.transport.connect({
+                joinUrl,
+                overrides,
+                debug: this.config.debug,
+                // roomState is intentionally omitted — provider sessions bypass room creation
+            });
+        }
+        catch (error) {
+            this.handleConnectionError(error instanceof Error ? error : new Error(String(error)));
+        }
+    }
+    /**
+     * Stop the current call
+     */
+    stop(code = 1000, reason = "client-stop") {
+        if (this.config.debug) {
+            console.debug("🛑 Stopping call:", { code, reason });
+        }
+        // Clear all timers
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+            this.reconnectTimer = null;
+        }
+        if (this.connectionTimeoutTimer) {
+            clearTimeout(this.connectionTimeoutTimer);
+            this.connectionTimeoutTimer = null;
+        }
+        // Stop ends this call intent — clear the Idempotency-Key so the next
+        // start() mints a fresh one (new intent → new interaction).
+        this.clearIdempotencyKey();
+        this.roomState = null;
+        if (this.transport) {
+            this.transport.disconnect(code, reason);
+        }
+        else {
+            this.emit("closed", code, reason);
+            this.cleanup();
+        }
+    }
+    /**
+     * Send a message to the server
+     */
+    send(message, shouldLog = true) {
+        if (!this.transport || !this.transport.isConnected()) {
+            if (this.config.debug) {
+                console.warn("⚠️ Cannot send message (type: " + message.type + "): not connected");
+            }
+            return;
+        }
+        // Block unsupported message types
+        if (message.type === "assistant-overrides" ||
+            message.type === "set-context" ||
+            message.type === "clear-context") {
+            if (this.config.debug) {
+                console.warn(`⚠️ Message type '${message.type}' not supported by current backend`);
+            }
+            return;
+        }
+        try {
+            this.transport.sendMessage(message);
+            if (this.config.debug && shouldLog) {
+                console.debug("📤 Sent message:", message);
+            }
+        }
+        catch (error) {
+            if (this.config.debug) {
+                console.error('❌ Error sending message:', error);
+            }
+            this.emit('error', error instanceof Error ? error : new Error(String(error)));
+        }
+    }
+    // ── Audio controls (delegated to transport) ────────────────────────────
+    deafen() {
+        if (this.audioDeafened)
+            return;
+        this.audioDeafened = true;
+        this.transport?.deafen();
+        this.emit("audio-deafened", true);
+    }
+    undeafen() {
+        if (!this.audioDeafened)
+            return;
+        this.audioDeafened = false;
+        this.transport?.undeafen();
+        this.emit("audio-undeafened", false);
+    }
+    toggleDeafen() {
+        this.audioDeafened ? this.undeafen() : this.deafen();
+    }
+    setVolume(volume) {
+        this.transport?.setVolume(volume);
+    }
+    muteMic() {
+        if (this.micMuted)
+            return;
+        this.micMuted = true;
+        this.emit("mic-muted");
+        this.transport?.muteMic();
+    }
+    async unmuteMic() {
+        if (!this.micMuted)
+            return;
+        this.micMuted = false;
+        this.emit("mic-unmuted");
+        try {
+            await this.transport?.unmuteMic();
+        }
+        catch (error) {
+            this.emit("error", error instanceof Error ? error : new Error(String(error)));
+        }
+    }
+    toggleMicMute() {
+        this.micMuted ? this.unmuteMic() : this.muteMic();
+    }
+    // ── Connection management ──────────────────────────────────────────────
+    /**
+     * Create room and connect via the appropriate transport.
+     */
+    async createRoomAndConnect(payload, overrides) {
+        try {
+            if (this.config.debug) {
+                console.debug('🏠 Creating websocket room...');
+            }
+            const room = await this.createRoom(payload);
+            this.roomState = {
+                roomId: room.id,
+                // The WebRTC /offer relay resolves the room by interactionId, not the
+                // room's own id. Prefer interactionId; fall back to id for safety.
+                interactionId: room.interactionId ?? room.id,
+                status: room.status,
+                websocketUrl: room.websocketUrl,
+                connectionParameters: room.connectionParameters,
+            };
+            if (room.status === types_1.WebsocketRoomStatus.Failed || room.status === types_1.WebsocketRoomStatus.Expired) {
+                throw new Error(`Room ${room.status}: ${room.id}`);
+            }
+            if (!room.websocketUrl) {
+                throw new Error('Room created but no websocket URL available');
+            }
+            this.state = types_1.AudialState.Connecting;
+            // Determine and create transport
+            const transportType = this.resolveTransportType();
+            const callbacks = this.createTransportCallbacks();
+            if (transportType === 'webrtc') {
+                const signalingUrl = this.resolveSignalingUrl();
+                this.transport = new webrtc_1.WebRTCTransport(callbacks, signalingUrl);
+                this.activeTransportType = 'webrtc';
+            }
+            else {
+                this.transport = new websocket_1.WebSocketTransport(callbacks);
+                this.activeTransportType = 'websocket';
+            }
+            if (this.config.debug) {
+                console.debug(`🚀 Using ${this.activeTransportType} transport`);
+            }
+            // Connect transport
+            try {
+                await this.transport.connect({
+                    roomState: this.roomState,
+                    overrides,
+                    debug: this.config.debug,
+                });
+            }
+            catch (transportError) {
+                // WebRTC failed — try falling back to WebSocket
+                if (this.activeTransportType === 'webrtc') {
+                    if (this.config.debug) {
+                        console.warn('⚠️ WebRTC failed, falling back to WebSocket:', transportError);
+                    }
+                    this.transport.destroy();
+                    this.transport = new websocket_1.WebSocketTransport(callbacks);
+                    this.activeTransportType = 'websocket';
+                    await this.transport.connect({
+                        roomState: this.roomState,
+                        overrides,
+                        debug: this.config.debug,
+                    });
+                }
+                else {
+                    throw transportError;
+                }
+            }
+        }
+        catch (error) {
+            this.roomState = null;
+            this.handleConnectionError(error instanceof Error ? error : new Error(String(error)));
+        }
+    }
+    /**
+     * Determine which transport to use based on config + browser capabilities.
+     *
+     * Default is 'auto': uses WebRTC if browser supports RTCPeerConnection,
+     * otherwise falls back to WebSocket. Signaling goes through the platform's
+     * /voice-ws/ proxy — no separate bot URL needed.
+     */
+    resolveTransportType() {
+        const requested = this.config.transport;
+        if (requested === 'websocket')
+            return 'websocket';
+        if (requested === 'webrtc')
+            return 'webrtc';
+        // Auto-detect: use WebRTC if browser supports it
+        if (typeof RTCPeerConnection !== 'undefined') {
+            return 'webrtc';
+        }
+        return 'websocket';
+    }
+    /**
+     * Get the WebRTC signaling relay URL.
+     *
+     * Points to the platform's bot provider endpoint which relays signaling
+     * to the voice-bot. Same URL in dev, staging, prod — no separate bot URL.
+     *
+     * POST {url}/offer/{interactionId} → platform → voice-bot /offer
+     * POST {url}/candidates → platform → voice-bot /candidates
+     */
+    resolveSignalingUrl() {
+        // Explicit override (testing, direct bot access)
+        const explicit = this.config.webrtcSignalingUrl;
+        if (explicit)
+            return explicit;
+        // Default: platform API signaling relay
+        return `${this.getHttpUrl()}/api/v1/bot/call/providers/webrtc`;
+    }
+    /**
+     * Create the callbacks object that wires transport events to Audial.
+     */
+    createTransportCallbacks() {
+        return {
+            onReady: () => {
+                // Cancel connection timeout
+                if (this.connectionTimeoutTimer) {
+                    clearTimeout(this.connectionTimeoutTimer);
+                    this.connectionTimeoutTimer = null;
+                }
+                // The call successfully connected — this intent is now
+                // "consumed." Any subsequent start() should create a new
+                // interaction, so clear the Idempotency-Key.
+                this.clearIdempotencyKey();
+                this.state = types_1.AudialState.Active;
+                this.emit('ready');
+            },
+            onMessage: (msg) => {
+                this.handleTransportMessage(msg);
+            },
+            onError: (error) => {
+                if (this.config.debug) {
+                    console.error('❌ Transport error:', error);
+                }
+                this.emit('error', error);
+            },
+            onClose: (code, reason) => {
+                if (this.config.debug) {
+                    console.debug('🔌 Transport closed:', { code, reason });
+                }
+                this.emit('closed', code, reason);
+                this.cleanup();
+            },
+        };
+    }
+    /**
+     * Handle messages from the transport. All event routing happens here.
+     * Audio handling is done internally by the transport — we only get
+     * the message for event emission purposes.
+     */
+    handleTransportMessage(msg) {
+        // Emit generic 'message' event for all types (hook uses this for config_loaded)
+        this.emit('message', msg);
+        switch (msg.type) {
+            case 'ready': {
+                // WebSocket sends {type:"ready"} explicitly — trigger ready logic here.
+                // WebRTC fires onReady from dc.onopen (no ready message).
+                // Safe to call multiple times — timeout clear is idempotent.
+                if (this.connectionTimeoutTimer) {
+                    clearTimeout(this.connectionTimeoutTimer);
+                    this.connectionTimeoutTimer = null;
+                }
+                if (this.state !== types_1.AudialState.Active) {
+                    this.state = types_1.AudialState.Active;
+                    this.emit('ready');
+                }
+                if (this.lastOverrides && this.config.debug) {
+                    console.warn('⚠️ Assistant overrides not supported by current backend');
+                }
+                break;
+            }
+            case 'speech-start': {
+                // Event name matches the declared AudialEventMap key (kebab-case).
+                // Previously emitted 'speechStart' (camelCase) via `as any`, which
+                // meant use-voice subscribers (which listen to 'speech-start') never
+                // fired — isAgentSpeaking stayed false for the entire call. Fixed
+                // while adding hook tests that caught the mismatch.
+                this.emit('speech-start');
+                break;
+            }
+            case 'speech-end': {
+                this.emit('speech-end');
+                break;
+            }
+            case 'call-end': {
+                if (this.config.debug) {
+                    console.debug("Message call-end received from server");
+                }
+                this.emit('closed', 1000, 'server-end');
+                this.stop();
+                break;
+            }
+            case 'error': {
+                this.emit('error', new Error(msg?.message));
+                break;
+            }
+            case 'transcript': {
+                this.emit('transcript', msg);
+                break;
+            }
+            case 'audio': {
+                // Audio is handled internally by WebSocketTransport — no action needed
+                break;
+            }
+            case 'node-update': {
+                if (this.config.debug) {
+                    console.debug("[Audial] Node update:", msg.node_id);
+                }
+                this.currentNodeId = msg.node_id;
+                this.emit('node-update', this.currentNodeId);
+                break;
+            }
+            case 'interruption': {
+                if (this.config.debug) {
+                    console.debug("[Audial] Interruption received - clearing audio buffer");
+                }
+                this.transport?.clearAudioBuffer();
+                this.emit('interruption');
+                break;
+            }
+        }
+    }
+    // ── Connection error + retry ──────────────────────────────────────────
+    handleConnectionError(error) {
+        if (this.config.debug) {
+            console.error('❌ Connection error:', error);
+        }
+        this.state = types_1.AudialState.Idle;
+        this.emit('error', error);
+        if (this.config.autoReconnect && this.retryCount < this.retryPolicy.maxRetries) {
+            this.retryCount++;
+            const delay = this.retryPolicy.backoffMs * Math.pow(2, this.retryCount - 1);
+            if (this.config.debug) {
+                console.debug(`🔄 Retrying connection in ${delay}ms (attempt ${this.retryCount}/${this.retryPolicy.maxRetries})`);
+            }
+            // If we already have a room from the initial createRoom(), reuse it on
+            // retry — only the TRANSPORT connection failed, not the room. Calling
+            // start() again would POST /interactions/websocket and leak a new
+            // "queued" interaction per retry. This was the zombie-interaction bug.
+            const roomToReuse = this.roomState;
+            this.reconnectTimer = setTimeout(() => {
+                if (roomToReuse) {
+                    this.retryTransportOnly(roomToReuse);
+                }
+                else {
+                    // No room yet (createRoom itself failed) — full start is safe.
+                    this.start(this.lastCallPayload, this.lastOverrides);
+                }
+            }, delay);
+        }
+        else {
+            this.cleanup();
+        }
+    }
+    /**
+     * Reconnect the transport layer without re-creating the platform room.
+     * Used by the retry path to avoid leaking a new "queued" interaction per
+     * attempt. The existing roomState is preserved; only a fresh transport
+     * is constructed and connected to the same room.
+     */
+    async retryTransportOnly(roomState) {
+        try {
+            if (this.transport) {
+                try {
+                    this.transport.destroy();
+                }
+                catch { /* ignore */ }
+                this.transport = null;
+            }
+            this.state = types_1.AudialState.Connecting;
+            this.roomState = roomState;
+            const transportType = this.resolveTransportType();
+            const callbacks = this.createTransportCallbacks();
+            if (transportType === 'webrtc') {
+                const signalingUrl = this.resolveSignalingUrl();
+                this.transport = new webrtc_1.WebRTCTransport(callbacks, signalingUrl);
+                this.activeTransportType = 'webrtc';
+            }
+            else {
+                this.transport = new websocket_1.WebSocketTransport(callbacks);
+                this.activeTransportType = 'websocket';
+            }
+            await this.transport.connect({
+                roomState,
+                overrides: this.lastOverrides,
+                debug: this.config.debug,
+            });
+        }
+        catch (error) {
+            this.handleConnectionError(error instanceof Error ? error : new Error(String(error)));
+        }
+    }
+    reconnect() {
+        if (this.lastCallPayload) {
+            if (this.config.debug) {
+                console.debug('🔄 Reconnecting...');
+            }
+            this.stop();
+            setTimeout(() => {
+                this.start(this.lastCallPayload, this.lastOverrides);
+            }, 100);
+        }
+        else {
+            throw new Error('Audial: no previous call to reconnect to');
+        }
+    }
+    // ── Connection status ─────────────────────────────────────────────────
+    getConnectionStatus() {
+        const baseStatus = {
+            connected: this.transport?.isConnected() ?? false,
+            state: this.state,
+            readyState: this.transport?.isConnected() ? 1 : null,
+            retryCount: this.retryCount,
+        };
+        if (this.roomState) {
+            baseStatus.roomState = this.roomState;
+        }
+        return baseStatus;
+    }
+    // ── Cleanup ───────────────────────────────────────────────────────────
+    cleanup() {
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+            this.reconnectTimer = null;
+        }
+        if (this.connectionTimeoutTimer) {
+            clearTimeout(this.connectionTimeoutTimer);
+            this.connectionTimeoutTimer = null;
+        }
+        this.roomState = null;
+        if (this.transport) {
+            this.transport.destroy();
+            this.transport = null;
+        }
+        this.activeTransportType = null;
+        this.state = types_1.AudialState.Idle;
+        this.removeAllListeners();
+    }
+    // ── Room creation (unchanged) ─────────────────────────────────────────
+    getHttpUrl() {
+        return this.config.baseUrl.startsWith('http')
+            ? this.config.baseUrl
+            : this.config.baseUrl.includes('localhost')
+                ? `http://${this.config.baseUrl}`
+                : `https://${this.config.baseUrl}`;
+    }
+    getBaseUrl() {
+        if (typeof window !== 'undefined' && window.__AUDIAL_CONFIG__) {
+            return window.__AUDIAL_CONFIG__.baseUrl;
+        }
+        if (typeof process !== 'undefined') {
+            const env = process.env;
+            if (env.AUDIAL_BASE_URL)
+                return env.AUDIAL_BASE_URL;
+            if (env.NODE_ENV === 'production' && env.AUDIAL_PROD_URL)
+                return env.AUDIAL_PROD_URL;
+            if (env.NODE_ENV === 'staging' && env.AUDIAL_STAGING_URL)
+                return env.AUDIAL_STAGING_URL;
+            if (env.NODE_ENV === 'development' && env.AUDIAL_DEV_URL)
+                return env.AUDIAL_DEV_URL;
+        }
+        if (typeof window !== 'undefined' && window.location && window.location.hostname) {
+            const hostname = window.location.hostname;
+            if (hostname === 'localhost' || hostname === '127.0.0.1') {
+                return 'localhost:8000';
+            }
+            if (hostname.includes('staging')) {
+                return 'lavoz-api-staging.fly.dev';
+            }
+            if (hostname.includes('production') || hostname.includes('audial.co') || hostname.includes('audial.ai')) {
+                return 'lavoz-api.fly.dev';
+            }
+        }
+        return 'lavoz-api.fly.dev';
+    }
+    async createRoom(payload) {
+        const baseUrl = `${this.getHttpUrl()}/api/v1/interactions/websocket`;
+        const fullPayload = {
+            type: 'voice',
+            provider: 'websocket',
+            direction: 'web',
+            agentId: payload.agentId,
+            agentSettings: payload.agentSettings
+                ? this.expandAgentSettings(payload.agentSettings)
+                : undefined,
+            languageCode: payload.languageCode,
+            customerId: payload.customerId,
+            userHash: payload.userHash,
+            customer: payload.customer,
+        };
+        const url = new URL(baseUrl);
+        this.applyPublicKeyAuth(url);
+        if (payload.agentId) {
+            url.searchParams.set('agentId', payload.agentId);
+        }
+        try {
+            const response = await fetch(url.toString(), {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    ...this.getAuthHeaders(),
+                    // IETF Idempotency-Key (draft-ietf-httpapi-idempotency-key-header-07).
+                    // Lets the server recognize retries of the same call intent and
+                    // return the existing interaction instead of leaking a new one.
+                    ...(this.idempotencyKey && { 'Idempotency-Key': this.idempotencyKey }),
+                },
+                body: JSON.stringify(fullPayload),
+            });
+            if (!response.ok) {
+                let errorMessage;
+                try {
+                    const errorText = await response.text();
+                    errorMessage = errorText || response.statusText || 'Unknown error';
+                }
+                catch {
+                    errorMessage = response.statusText || 'Failed to read error response';
+                }
+                throw new Error(`Room creation failed [${response.status}]: ${errorMessage}`);
+            }
+            try {
+                const result = await response.json();
+                const room = result.data?.data || result.data || result;
+                if (room.expiresAt instanceof Date)
+                    room.expiresAt = room.expiresAt.toISOString();
+                if (room.createdAt instanceof Date)
+                    room.createdAt = room.createdAt.toISOString();
+                if (room.updatedAt instanceof Date)
+                    room.updatedAt = room.updatedAt.toISOString();
+                return room;
+            }
+            catch (parseError) {
+                throw new Error(`Room creation succeeded but response is not valid JSON: ${parseError instanceof Error ? parseError.message : 'Parse error'}`);
+            }
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                if (error.message.includes('Room creation failed'))
+                    throw error;
+                throw new Error(`Network error during room creation: ${error.message}`);
+            }
+            throw new Error(`Unexpected error during room creation: ${String(error)}`);
+        }
+    }
+    // ── Idempotency-Key helpers ───────────────────────────────────────────
+    /**
+     * Mint a new Idempotency-Key, or restore one from sessionStorage if a
+     * recent key exists (within IDEMPOTENCY_MAX_AGE_MS). Restore path
+     * handles the "user refreshed the tab during a pending connect" case:
+     * the original interaction is still queued on the server, and reusing
+     * the key gets us back the same interaction instead of leaking a new
+     * one.
+     */
+    restoreOrMintIdempotencyKey() {
+        try {
+            if (typeof sessionStorage !== 'undefined') {
+                const cached = sessionStorage.getItem(VoiceClient.IDEMPOTENCY_STORAGE_KEY);
+                const at = Number(sessionStorage.getItem(VoiceClient.IDEMPOTENCY_STORAGE_AT) || 0);
+                if (cached && Date.now() - at < VoiceClient.IDEMPOTENCY_MAX_AGE_MS) {
+                    if (this.config.debug) {
+                        console.debug('🔑 Restored Idempotency-Key from sessionStorage:', cached.slice(0, 8) + '…');
+                    }
+                    return cached;
+                }
+            }
+        }
+        catch { /* private-mode / SSR — fall through to minting */ }
+        const fresh = this.mintUuid();
+        try {
+            if (typeof sessionStorage !== 'undefined') {
+                sessionStorage.setItem(VoiceClient.IDEMPOTENCY_STORAGE_KEY, fresh);
+                sessionStorage.setItem(VoiceClient.IDEMPOTENCY_STORAGE_AT, String(Date.now()));
+            }
+        }
+        catch { /* ignore */ }
+        if (this.config.debug) {
+            console.debug('🔑 Minted Idempotency-Key:', fresh.slice(0, 8) + '…');
+        }
+        return fresh;
+    }
+    clearIdempotencyKey() {
+        this.idempotencyKey = null;
+        try {
+            if (typeof sessionStorage !== 'undefined') {
+                sessionStorage.removeItem(VoiceClient.IDEMPOTENCY_STORAGE_KEY);
+                sessionStorage.removeItem(VoiceClient.IDEMPOTENCY_STORAGE_AT);
+            }
+        }
+        catch { /* ignore */ }
+    }
+    /**
+     * Generate a UUID v4. Prefers crypto.randomUUID() (modern browsers +
+     * Node 14.17+); falls back to a getRandomValues-backed implementation,
+     * and finally Math.random if neither is available (SSR test envs).
+     */
+    mintUuid() {
+        try {
+            if (typeof crypto !== 'undefined' && typeof crypto.randomUUID === 'function') {
+                return crypto.randomUUID();
+            }
+            if (typeof crypto !== 'undefined' && typeof crypto.getRandomValues === 'function') {
+                const bytes = new Uint8Array(16);
+                crypto.getRandomValues(bytes);
+                bytes[6] = (bytes[6] & 0x0f) | 0x40; // v4
+                bytes[8] = (bytes[8] & 0x3f) | 0x80; // RFC 4122 variant
+                const hex = Array.from(bytes, (b) => b.toString(16).padStart(2, '0')).join('');
+                return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+            }
+        }
+        catch { /* fall through */ }
+        // Last resort — low entropy but still unique enough to avoid self-collision
+        return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}-${Math.random().toString(36).slice(2, 10)}`;
+    }
+    expandAgentSettings(simple) {
+        return {
+            name: simple.name || 'WebSDK Agent',
+            languageCode: simple.languageCode || 'en',
+            prompt: simple.prompt || 'You are a helpful assistant.',
+            model: {
+                provider: simple.model?.provider || (typeof simple.model === 'string' ? 'openai' : 'openai'),
+                model: simple.model?.model || (typeof simple.model === 'string' ? simple.model : 'gpt-4'),
+                temperature: simple.model?.temperature ?? 0.7,
+                storeCompletions: simple.model?.storeCompletions ?? true,
+            },
+            voice: {
+                provider: 'elevenlabs',
+                voiceId: simple.voiceId || '21m00Tcm4TlvDq8ikWAM',
+                stability: 0.6,
+                similarityBoost: 0.9,
+            },
+            transcriber: {
+                provider: 'deepgram',
+                model: 'nova-2',
+            },
+            tools: simple.tools || [],
+            routings: simple.routings || [],
+            maxDurationSeconds: simple.maxDurationSeconds || 600,
+            checkHumanPresence: simple.checkHumanPresence ?? true,
+            checkHumanPresenceCount: simple.checkHumanPresenceCount || 2,
+            allowedIdleTime: simple.allowedIdleTime || 30,
+            allowInterruptions: simple.allowInterruptions ?? true,
+            interruptionSensitivity: simple.interruptionSensitivity || 'high',
+            enableCutoffResponses: simple.enableCutoffResponses ?? false,
+            cutoffResponses: simple.cutoffResponses || [],
+        };
+    }
+    // ═══════════════════════════════════════════════════════════════════════
+    // CHAT API METHODS (unchanged — purely HTTP, no transport dependency)
+    // ═══════════════════════════════════════════════════════════════════════
+    async createChatSession(agentId, options = {}) {
+        if (this.chatState !== types_1.ChatState.Idle && this.chatState !== types_1.ChatState.Ended) {
+            throw new Error('Chat session already active. End current session first.');
+        }
+        this.setChatState(types_1.ChatState.Creating);
+        const url = new URL(`${this.getHttpUrl()}/api/v1/interactions/chat`);
+        this.applyPublicKeyAuth(url);
+        url.searchParams.set('agentId', agentId);
+        try {
+            const response = await fetch(url.toString(), {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json', ...this.getAuthHeaders() },
+                body: JSON.stringify(options),
+            });
+            if (!response.ok) {
+                const errorText = await response.text().catch(() => 'Unknown error');
+                throw new Error(`Failed to create chat session [${response.status}]: ${errorText}`);
+            }
+            const result = await response.json();
+            const sessionData = result.data?.data || result.data || result;
+            this.chatSession = {
+                sessionId: sessionData.sessionId,
+                interactionId: sessionData.interactionId || sessionData.sessionId,
+                agentId: sessionData.agentId,
+                agentName: sessionData.agentName,
+                model: sessionData.model,
+                messages: [],
+                createdAt: sessionData.createdAt,
+            };
+            this.chatMessages = [];
+            this.setChatState(types_1.ChatState.Active);
+            this.emit('chat-session-created', sessionData);
+            if (this.config.debug) {
+                console.debug('💬 Chat session created:', sessionData);
+            }
+            return sessionData;
+        }
+        catch (error) {
+            this.setChatState(types_1.ChatState.Error);
+            this.emit('error', error instanceof Error ? error : new Error(String(error)));
+            throw error;
+        }
+    }
+    async sendChatMessage(message) {
+        if (!this.chatSession) {
+            throw new Error('No active chat session. Create a session first.');
+        }
+        if (this.chatState === types_1.ChatState.Sending) {
+            throw new Error('Message already being sent. Wait for response.');
+        }
+        if (!message.trim()) {
+            throw new Error('Message cannot be empty.');
+        }
+        const previousState = this.chatState;
+        this.setChatState(types_1.ChatState.Sending);
+        const userMessage = {
+            role: 'user',
+            content: message,
+            timestamp: new Date().toISOString(),
+        };
+        this.chatMessages.push(userMessage);
+        if (this.chatSession) {
+            this.chatSession.messages.push(userMessage);
+        }
+        const url = new URL(`${this.getHttpUrl()}/api/v1/interactions/${this.chatSession.interactionId}/message`);
+        this.applyPublicKeyAuth(url);
+        try {
+            const response = await fetch(url.toString(), {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json', ...this.getAuthHeaders() },
+                body: JSON.stringify({ message }),
+            });
+            if (!response.ok) {
+                const errorText = await response.text().catch(() => 'Unknown error');
+                throw new Error(`Failed to send message [${response.status}]: ${errorText}`);
+            }
+            const result = await response.json();
+            const messageData = result.data?.data || result.data || result;
+            const assistantMessage = {
+                role: 'assistant',
+                content: messageData.message,
+                timestamp: new Date().toISOString(),
+            };
+            this.chatMessages.push(assistantMessage);
+            if (this.chatSession) {
+                this.chatSession.messages.push(assistantMessage);
+            }
+            this.setChatState(types_1.ChatState.Active);
+            this.emit('chat-message', messageData);
+            if (this.config.debug) {
+                console.debug('💬 Chat message sent:', { sent: message, received: messageData.message });
+            }
+            return messageData;
+        }
+        catch (error) {
+            this.setChatState(previousState);
+            this.emit('error', error instanceof Error ? error : new Error(String(error)));
+            throw error;
+        }
+    }
+    async streamChatMessage(message, onChunk) {
+        if (!this.chatSession) {
+            throw new Error('No active chat session. Create a session first.');
+        }
+        if (this.chatState === types_1.ChatState.Sending) {
+            throw new Error('Message already being sent. Wait for response.');
+        }
+        if (!message.trim()) {
+            throw new Error('Message cannot be empty.');
+        }
+        const previousState = this.chatState;
+        this.setChatState(types_1.ChatState.Sending);
+        const userMessage = {
+            role: 'user',
+            content: message,
+            timestamp: new Date().toISOString(),
+        };
+        this.chatMessages.push(userMessage);
+        if (this.chatSession) {
+            this.chatSession.messages.push(userMessage);
+        }
+        const url = new URL(`${this.getHttpUrl()}/api/v1/interactions/${this.chatSession.interactionId}/message`);
+        this.applyPublicKeyAuth(url);
+        url.searchParams.set('stream', 'true');
+        try {
+            const response = await fetch(url.toString(), {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json', ...this.getAuthHeaders() },
+                body: JSON.stringify({ message }),
+            });
+            if (!response.ok) {
+                const errorText = await response.text().catch(() => 'Unknown error');
+                throw new Error(`Failed to stream message [${response.status}]: ${errorText}`);
+            }
+            const reader = response.body?.getReader();
+            if (!reader) {
+                throw new Error('Response body is not readable (streaming not supported by environment)');
+            }
+            const decoder = new TextDecoder();
+            let fullText = '';
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                const chunk = decoder.decode(value, { stream: true });
+                fullText += chunk;
+                onChunk(chunk);
+            }
+            const sessionId = this.chatSession?.sessionId || '';
+            const messageData = { sessionId, message: fullText };
+            const assistantMessage = {
+                role: 'assistant',
+                content: fullText,
+                timestamp: new Date().toISOString(),
+            };
+            this.chatMessages.push(assistantMessage);
+            if (this.chatSession) {
+                this.chatSession.messages.push(assistantMessage);
+            }
+            this.setChatState(types_1.ChatState.Active);
+            this.emit('chat-message', messageData);
+            if (this.config.debug) {
+                console.debug('💬 Chat message streamed:', { sent: message, received: fullText.substring(0, 100) + (fullText.length > 100 ? '...' : '') });
+            }
+            return messageData;
+        }
+        catch (error) {
+            this.setChatState(previousState);
+            this.emit('error', error instanceof Error ? error : new Error(String(error)));
+            throw error;
+        }
+    }
+    async getChatHistory() {
+        if (!this.chatSession) {
+            throw new Error('No active chat session.');
+        }
+        const url = new URL(`${this.getHttpUrl()}/api/v1/interactions/${this.chatSession.interactionId}/messages`);
+        this.applyPublicKeyAuth(url);
+        try {
+            const response = await fetch(url.toString(), {
+                headers: { ...this.getAuthHeaders() },
+            });
+            if (!response.ok) {
+                const errorText = await response.text().catch(() => 'Unknown error');
+                throw new Error(`Failed to get chat history [${response.status}]: ${errorText}`);
+            }
+            const result = await response.json();
+            const historyData = result.data?.data || result.data || result;
+            this.chatMessages = historyData.messages;
+            if (this.chatSession) {
+                this.chatSession.messages = historyData.messages;
+            }
+            if (this.config.debug) {
+                console.debug('💬 Chat history retrieved:', historyData.messages.length, 'messages');
+            }
+            return historyData;
+        }
+        catch (error) {
+            this.emit('error', error instanceof Error ? error : new Error(String(error)));
+            throw error;
+        }
+    }
+    async endChatSession() {
+        if (!this.chatSession) {
+            if (this.config.debug) {
+                console.debug('💬 No active chat session to end');
+            }
+            return;
+        }
+        this.setChatState(types_1.ChatState.Ending);
+        const interactionId = this.chatSession.interactionId;
+        const url = new URL(`${this.getHttpUrl()}/api/v1/interactions/${interactionId}/end`);
+        this.applyPublicKeyAuth(url);
+        try {
+            const response = await fetch(url.toString(), {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json', ...this.getAuthHeaders() },
+                body: JSON.stringify({}),
+            });
+            if (!response.ok) {
+                const errorText = await response.text().catch(() => 'Unknown error');
+                throw new Error(`Failed to end chat session [${response.status}]: ${errorText}`);
+            }
+            this.chatSession = null;
+            this.chatMessages = [];
+            this.setChatState(types_1.ChatState.Ended);
+            this.emit('chat-session-ended', interactionId);
+            if (this.config.debug) {
+                console.debug('💬 Chat session ended:', interactionId);
+            }
+        }
+        catch (error) {
+            this.setChatState(types_1.ChatState.Error);
+            this.emit('error', error instanceof Error ? error : new Error(String(error)));
+            throw error;
+        }
+    }
+    getChatState() {
+        return this.chatState;
+    }
+    getChatSession() {
+        return this.chatSession;
+    }
+    getChatMessages() {
+        return [...this.chatMessages];
+    }
+    hasChatSession() {
+        return this.chatSession !== null && this.chatState === types_1.ChatState.Active;
+    }
+    setChatState(state) {
+        if (this.chatState !== state) {
+            this.chatState = state;
+            this.emit('chat-state-change', state);
+        }
+    }
+    resetChatState() {
+        this.chatState = types_1.ChatState.Idle;
+        this.chatSession = null;
+        this.chatMessages = [];
+    }
+}
+exports.VoiceClient = VoiceClient;
+VoiceClient.IDEMPOTENCY_STORAGE_KEY = 'chanl:voice-idem-key';
+VoiceClient.IDEMPOTENCY_STORAGE_AT = 'chanl:voice-idem-at';
+VoiceClient.IDEMPOTENCY_MAX_AGE_MS = 120000; // 2 min
+//# sourceMappingURL=voice-client.js.map