@convai/web-sdk 0.3.1-beta.3 → 0.3.2-beta.0

package/dist/core/index.cjs

@@ -1,1977 +0,0 @@
-'use strict';
-
-var livekitClient = require('livekit-client');
-
-/**
- * Logger utility that only logs in development mode.
- * Completely silent in production builds and npm packages.
- *
- * This logger is designed to be tree-shakeable and completely removed
- * from production builds when not used.
- *
- * To test logger behavior:
- * - Development: Set NODE_ENV=development or run on localhost
- * - Production: Set NODE_ENV=production or deploy to production
- *
- * In npm packages, this logger will be completely silent by default.
- */
-// Environment detection with multiple fallbacks
-const detectEnvironment = () => {
-    // Check if we're in a browser environment
-    const isBrowser = typeof window !== 'undefined';
-    // Safe process.env access (Vite/Webpack replaces this at build time)
-    const getEnv = (key) => {
-        try {
-            // @ts-ignore - process.env is replaced at build time by bundlers
-            return typeof process !== 'undefined' && process.env ? process.env[key] : undefined;
-        }
-        catch {
-            return undefined;
-        }
-    };
-    // Priority 1: Check NEXT_PUBLIC_ENVIRONMENT first (most explicit)
-    const publicEnv = getEnv('NEXT_PUBLIC_ENVIRONMENT');
-    if (publicEnv === 'PRODUCTION') {
-        return 'production';
-    }
-    if (publicEnv === 'PREVIEW' || publicEnv === 'STAGING') {
-        return 'development';
-    }
-    // Priority 2: Check NODE_ENV and REACT_APP_ENV (Vite replaces import.meta.env.MODE)
-    const nodeEnv = getEnv('NODE_ENV');
-    const reactEnv = getEnv('REACT_APP_ENV');
-    if (nodeEnv === 'production' || reactEnv === 'production') {
-        return 'production';
-    }
-    if (nodeEnv === 'development' || reactEnv === 'development') {
-        return 'development';
-    }
-    // Priority 3: Check for Vite dev server
-    const viteDevUrl = getEnv('VITE_DEV_SERVER_URL');
-    if (viteDevUrl !== undefined) {
-        return 'development';
-    }
-    // Priority 4: Check browser environment (only if no explicit env vars are set)
-    if (isBrowser) {
-        // Localhost is typically development
-        if (window.location?.hostname === 'localhost' || window.location?.hostname === '127.0.0.1') {
-            return 'development';
-        }
-        // Check for development ports
-        if (window.location?.port && ['3000', '3001', '5173', '8080'].includes(window.location.port)) {
-            return 'development';
-        }
-    }
-    // Default to production for safety
-    return 'production';
-};
-const environment = detectEnvironment();
-const isDevelopment = environment === 'development';
-// No-op function that gets completely removed by tree shaking
-const noop = () => {
-    // This function is intentionally empty and will be removed in production
-};
-// Development logger functions
-const devLogger = {
-    log: (...args) => console.log('[Convai]', ...args),
-    warn: (...args) => console.warn('[Convai]', ...args),
-    error: (...args) => console.error('[Convai]', ...args),
-    info: (...args) => console.info('[Convai]', ...args),
-    debug: (...args) => console.debug('[Convai]', ...args),
-    trace: (...args) => console.trace('[Convai]', ...args),
-};
-// Production logger functions (all no-ops)
-const prodLogger = {
-    log: noop,
-    warn: noop,
-    error: noop,
-    info: noop,
-    debug: noop,
-    trace: noop,
-};
-// Export the appropriate logger based on environment
-const logger = isDevelopment ? devLogger : prodLogger;
-
-class EventEmitter {
-    constructor() {
-        this.events = new Map();
-    }
-    /**
-     * Subscribe to an event
-     * @param event Event name
-     * @param callback Callback function
-     * @returns Unsubscribe function
-     */
-    on(event, callback) {
-        if (!this.events.has(event)) {
-            this.events.set(event, new Set());
-        }
-        this.events.get(event).add(callback);
-        // Return unsubscribe function
-        return () => {
-            this.off(event, callback);
-        };
-    }
-    /**
-     * Unsubscribe from an event
-     * @param event Event name
-     * @param callback Callback function to remove
-     */
-    off(event, callback) {
-        const callbacks = this.events.get(event);
-        if (callbacks) {
-            callbacks.delete(callback);
-            if (callbacks.size === 0) {
-                this.events.delete(event);
-            }
-        }
-    }
-    /**
-     * Emit an event to all subscribers
-     * @param event Event name
-     * @param args Arguments to pass to callbacks
-     */
-    emit(event, ...args) {
-        const callbacks = this.events.get(event);
-        if (callbacks) {
-            callbacks.forEach((callback) => {
-                try {
-                    callback(...args);
-                }
-                catch (error) {
-                    console.error(`Error in event handler for "${event}":`, error);
-                }
-            });
-        }
-    }
-    /**
-     * Remove all event listeners
-     */
-    removeAllListeners() {
-        this.events.clear();
-    }
-    /**
-     * Get the number of listeners for an event
-     * @param event Event name
-     * @returns Number of listeners
-     */
-    listenerCount(event) {
-        return this.events.get(event)?.size ?? 0;
-    }
-}
-
-/**
- * Manages audio controls for LiveKit room
- * Provides methods to enable/disable microphone, manage audio devices,
- * and control audio state.
- */
-class AudioManager extends EventEmitter {
-    constructor(room) {
-        super();
-        this.room = null;
-        this._isAudioEnabled = false;
-        this._isAudioMuted = false;
-        this._audioLevel = 0;
-        if (room) {
-            this.setRoom(room);
-        }
-    }
-    get isAudioEnabled() {
-        return this._isAudioEnabled;
-    }
-    get isAudioMuted() {
-        return this._isAudioMuted;
-    }
-    get audioLevel() {
-        return this._audioLevel;
-    }
-    /**
-     * Set the LiveKit room instance
-     */
-    setRoom(room) {
-        // Clean up previous room listeners
-        if (this.room) {
-            this.cleanupListeners();
-        }
-        this.room = room;
-        if (room && room.state !== 'disconnected') {
-            this.setupListeners();
-            this.updateState();
-        }
-    }
-    /**
-     * Setup event listeners for room
-     */
-    setupListeners() {
-        if (!this.room)
-            return;
-        const localParticipant = this.room.localParticipant;
-        const handleTrackMuted = (track) => {
-            if (track.source === 'microphone') {
-                this._isAudioMuted = true;
-                this._isAudioEnabled = false;
-                this.emit('audioStateChange', { isAudioMuted: true, isAudioEnabled: false });
-            }
-        };
-        const handleTrackUnmuted = (track) => {
-            if (track.source === 'microphone') {
-                this._isAudioMuted = false;
-                this._isAudioEnabled = true;
-                this.emit('audioStateChange', { isAudioMuted: false, isAudioEnabled: true });
-            }
-        };
-        const handleTrackPublished = (track) => {
-            if (track.source === 'microphone') {
-                this._isAudioEnabled = true;
-                this._isAudioMuted = false;
-                this.emit('audioStateChange', { isAudioMuted: false, isAudioEnabled: true });
-            }
-        };
-        const handleTrackUnpublished = (track) => {
-            if (track.source === 'microphone') {
-                this._isAudioEnabled = false;
-                this._isAudioMuted = true;
-                this.emit('audioStateChange', { isAudioMuted: true, isAudioEnabled: false });
-            }
-        };
-        localParticipant.on('trackMuted', handleTrackMuted);
-        localParticipant.on('trackUnmuted', handleTrackUnmuted);
-        localParticipant.on('trackPublished', handleTrackPublished);
-        localParticipant.on('trackUnpublished', handleTrackUnpublished);
-    }
-    /**
-     * Clean up event listeners
-     */
-    cleanupListeners() {
-        if (!this.room)
-            return;
-        // LiveKit handles cleanup automatically when participant is removed
-    }
-    /**
-     * Force-sync the stored audio state with the underlying LiveKit room.
-     * Useful right after a connection completes so the UI can reflect
-     * the current microphone permission without waiting for a toggle event.
-     */
-    syncStateFromRoom(options = {}) {
-        const { emit = false } = options;
-        if (!this.room || this.room.state === 'disconnected') {
-            const stateChanged = this._isAudioEnabled !== false ||
-                this._isAudioMuted !== true ||
-                this._audioLevel !== 0;
-            this._isAudioEnabled = false;
-            this._isAudioMuted = true;
-            this._audioLevel = 0;
-            if (emit && stateChanged) {
-                this.emit('audioStateChange', {
-                    isAudioMuted: this._isAudioMuted,
-                    isAudioEnabled: this._isAudioEnabled,
-                    audioLevel: this._audioLevel,
-                });
-            }
-            return;
-        }
-        const localParticipant = this.room.localParticipant;
-        const isMicEnabled = localParticipant?.isMicrophoneEnabled ?? false;
-        const nextMutedState = !isMicEnabled;
-        const stateChanged = this._isAudioEnabled !== isMicEnabled ||
-            this._isAudioMuted !== nextMutedState;
-        this._isAudioEnabled = isMicEnabled;
-        this._isAudioMuted = nextMutedState;
-        if (emit && stateChanged) {
-            this.emit('audioStateChange', {
-                isAudioMuted: this._isAudioMuted,
-                isAudioEnabled: this._isAudioEnabled,
-                audioLevel: this._audioLevel,
-            });
-        }
-    }
-    /**
-     * Update audio state from room
-     */
-    updateState() {
-        this.syncStateFromRoom();
-    }
-    /**
-     * Enable audio
-     */
-    async enableAudio() {
-        if (!this.room) {
-            throw new Error('Room not initialized');
-        }
-        try {
-            await this.room.localParticipant.setMicrophoneEnabled(true);
-            this._isAudioEnabled = true;
-            this._isAudioMuted = false;
-            this.emit('audioStateChange', {
-                isAudioMuted: false,
-                isAudioEnabled: true,
-                audioLevel: this._audioLevel,
-            });
-        }
-        catch (error) {
-            logger.error("Failed to enable audio:", error);
-            throw error;
-        }
-    }
-    /**
-     * Disable audio and completely release microphone
-     */
-    async disableAudio() {
-        if (!this.room) {
-            throw new Error('Room not initialized');
-        }
-        try {
-            // Get the microphone track before disabling
-            const micTrack = Array.from(this.room.localParticipant.audioTrackPublications.values()).find((publication) => publication.source === 'microphone' && publication.track)?.track;
-            // Disable microphone (unpublishes the track)
-            await this.room.localParticipant.setMicrophoneEnabled(false);
-            // Explicitly stop the underlying MediaStreamTrack to release hardware
-            // This removes the browser recording indicator
-            if (micTrack) {
-                micTrack.stop();
-            }
-            this._isAudioEnabled = false;
-            this._isAudioMuted = true;
-            this.emit('audioStateChange', {
-                isAudioMuted: true,
-                isAudioEnabled: false,
-                audioLevel: 0,
-            });
-        }
-        catch (error) {
-            logger.error("Failed to disable audio:", error);
-            throw error;
-        }
-    }
-    /**
-     * Mute audio
-     */
-    async muteAudio() {
-        await this.disableAudio();
-    }
-    /**
-     * Unmute audio
-     */
-    async unmuteAudio() {
-        await this.enableAudio();
-    }
-    /**
-     * Toggle audio
-     */
-    async toggleAudio() {
-        if (this._isAudioMuted) {
-            await this.unmuteAudio();
-        }
-        else {
-            await this.muteAudio();
-        }
-    }
-    /**
-     * Set audio device
-     */
-    async setAudioDevice(deviceId) {
-        if (!this.room) {
-            throw new Error('Room not initialized');
-        }
-        try {
-            await this.room.localParticipant.setMicrophoneEnabled(true, { deviceId });
-        }
-        catch (error) {
-            logger.error("Failed to set audio device:", error);
-            throw error;
-        }
-    }
-    /**
-     * Get available audio devices
-     */
-    async getAudioDevices() {
-        try {
-            const devices = await navigator.mediaDevices.enumerateDevices();
-            const audioDevices = devices.filter(device => device.kind === 'audioinput');
-            return audioDevices;
-        }
-        catch (error) {
-            logger.error("Failed to get audio devices:", error);
-            throw error;
-        }
-    }
-    /**
-     * Start audio level monitoring
-     */
-    startAudioLevelMonitoring() {
-        if (!this.room) {
-            return;
-        }
-        // TODO: Implement audio level monitoring when LiveKit provides the API
-    }
-    /**
-     * Stop audio level monitoring
-     */
-    stopAudioLevelMonitoring() {
-        this._audioLevel = 0;
-    }
-    /**
-     * Reset state on disconnect
-     */
-    reset() {
-        this._isAudioEnabled = false;
-        this._isAudioMuted = false;
-        this._audioLevel = 0;
-        this.emit('audioStateChange', {
-            isAudioMuted: false,
-            isAudioEnabled: false,
-            audioLevel: 0
-        });
-    }
-}
-
-/**
- * Manages video controls for LiveKit room
- * Provides methods to enable/disable camera, manage video devices,
- * and control video state.
- */
-class VideoManager extends EventEmitter {
-    constructor(room) {
-        super();
-        this.room = null;
-        this._isVideoEnabled = false;
-        this._isVideoHidden = false;
-        if (room) {
-            this.setRoom(room);
-        }
-    }
-    get isVideoEnabled() {
-        return this._isVideoEnabled;
-    }
-    get isVideoHidden() {
-        return this._isVideoHidden;
-    }
-    /**
-     * Set the LiveKit room instance
-     */
-    setRoom(room) {
-        // Clean up previous room listeners
-        if (this.room) {
-            this.cleanupListeners();
-        }
-        this.room = room;
-        if (room && room.state !== 'disconnected') {
-            this.setupListeners();
-            this.updateState();
-        }
-    }
-    /**
-     * Setup event listeners for room
-     */
-    setupListeners() {
-        if (!this.room)
-            return;
-        const localParticipant = this.room.localParticipant;
-        const handleTrackMuted = (track) => {
-            if (track.source === 'camera') {
-                this._isVideoHidden = true;
-                this.emit('videoStateChange', { isVideoHidden: true });
-            }
-        };
-        const handleTrackUnmuted = (track) => {
-            if (track.source === 'camera') {
-                this._isVideoHidden = false;
-                this.emit('videoStateChange', { isVideoHidden: false });
-            }
-        };
-        const handleTrackPublished = (publication) => {
-            if (publication.source === 'camera') {
-                this._isVideoEnabled = true;
-                this.emit('videoStateChange', { isVideoEnabled: true });
-            }
-        };
-        const handleTrackUnpublished = (publication) => {
-            if (publication.source === 'camera') {
-                this._isVideoEnabled = false;
-                this.emit('videoStateChange', { isVideoEnabled: false });
-            }
-        };
-        localParticipant.on('trackMuted', handleTrackMuted);
-        localParticipant.on('trackUnmuted', handleTrackUnmuted);
-        localParticipant.on('trackPublished', handleTrackPublished);
-        localParticipant.on('trackUnpublished', handleTrackUnpublished);
-    }
-    /**
-     * Clean up event listeners
-     */
-    cleanupListeners() {
-        if (!this.room)
-            return;
-        // LiveKit handles cleanup automatically when participant is removed
-    }
-    /**
-     * Update video state from room
-     */
-    updateState() {
-        if (!this.room || this.room.state === 'disconnected') {
-            this._isVideoEnabled = false;
-            this._isVideoHidden = false;
-            return;
-        }
-        const localParticipant = this.room.localParticipant;
-        this._isVideoEnabled = localParticipant.isCameraEnabled;
-        this._isVideoHidden = false; // LiveKit doesn't have a direct hidden state for video
-    }
-    /**
-     * Enable video
-     */
-    async enableVideo() {
-        if (!this.room) {
-            throw new Error('Room not initialized');
-        }
-        try {
-            await this.room.localParticipant.setCameraEnabled(true);
-            this._isVideoEnabled = true;
-            this.emit('videoStateChange', { isVideoEnabled: true });
-        }
-        catch (error) {
-            logger.error("Failed to enable video:", error);
-            throw error;
-        }
-    }
-    /**
-     * Disable video
-     */
-    async disableVideo() {
-        if (!this.room) {
-            throw new Error('Room not initialized');
-        }
-        try {
-            await this.room.localParticipant.setCameraEnabled(false);
-            this._isVideoEnabled = false;
-            this.emit('videoStateChange', { isVideoEnabled: false });
-        }
-        catch (error) {
-            logger.error("Failed to disable video:", error);
-            throw error;
-        }
-    }
-    /**
-     * Hide video
-     */
-    async hideVideo() {
-        await this.disableVideo();
-    }
-    /**
-     * Show video
-     */
-    async showVideo() {
-        await this.enableVideo();
-    }
-    /**
-     * Toggle video
-     */
-    async toggleVideo() {
-        if (this._isVideoEnabled) {
-            await this.disableVideo();
-        }
-        else {
-            await this.enableVideo();
-        }
-    }
-    /**
-     * Set video device
-     */
-    async setVideoDevice(deviceId) {
-        if (!this.room) {
-            throw new Error('Room not initialized');
-        }
-        try {
-            await this.room.localParticipant.setCameraEnabled(true, { deviceId });
-        }
-        catch (error) {
-            logger.error("Failed to set video device:", error);
-            throw error;
-        }
-    }
-    /**
-     * Get available video devices
-     */
-    async getVideoDevices() {
-        try {
-            const devices = await navigator.mediaDevices.enumerateDevices();
-            const videoDevices = devices.filter(device => device.kind === 'videoinput');
-            return videoDevices;
-        }
-        catch (error) {
-            logger.error("Failed to get video devices:", error);
-            throw error;
-        }
-    }
-    /**
-     * Set video quality
-     */
-    async setVideoQuality(quality) {
-        if (!this.room) {
-            throw new Error('Room not initialized');
-        }
-        try {
-            // TODO: Implement video quality settings when LiveKit provides the API
-            logger.warn('Video quality setting not yet implemented');
-        }
-        catch (error) {
-            logger.error("Failed to set video quality:", error);
-            throw error;
-        }
-    }
-    /**
-     * Reset state on disconnect
-     */
-    reset() {
-        this._isVideoEnabled = false;
-        this._isVideoHidden = false;
-        this.emit('videoStateChange', {
-            isVideoEnabled: false,
-            isVideoHidden: false
-        });
-    }
-}
-
-/**
- * Manages screen sharing controls for LiveKit room
- * Provides methods to enable/disable screen sharing, manage screen share state,
- * and handle screen sharing with audio support.
- */
-class ScreenShareManager extends EventEmitter {
-    constructor(room) {
-        super();
-        this.room = null;
-        this._isScreenShareEnabled = false;
-        this._isScreenShareActive = false;
-        if (room) {
-            this.setRoom(room);
-        }
-    }
-    get isScreenShareEnabled() {
-        return this._isScreenShareEnabled;
-    }
-    get isScreenShareActive() {
-        return this._isScreenShareActive;
-    }
-    /**
-     * Set the LiveKit room instance
-     */
-    setRoom(room) {
-        // Clean up previous room listeners
-        if (this.room) {
-            this.cleanupListeners();
-        }
-        this.room = room;
-        if (room && room.state !== 'disconnected') {
-            this.setupListeners();
-            this.updateState();
-        }
-    }
-    /**
-     * Setup event listeners for room
-     */
-    setupListeners() {
-        if (!this.room)
-            return;
-        const localParticipant = this.room.localParticipant;
-        const handleTrackPublished = (track) => {
-            if (track.source === 'screen_share') {
-                this._isScreenShareActive = true;
-                this.emit('screenShareStateChange', { isScreenShareActive: true });
-            }
-        };
-        const handleTrackUnpublished = (track) => {
-            if (track.source === 'screen_share') {
-                this._isScreenShareActive = false;
-                this.emit('screenShareStateChange', { isScreenShareActive: false });
-            }
-        };
-        const handleTrackMuted = (track) => {
-            if (track.source === 'screen_share') {
-                this._isScreenShareActive = false;
-                this.emit('screenShareStateChange', { isScreenShareActive: false });
-            }
-        };
-        const handleTrackUnmuted = (track) => {
-            if (track.source === 'screen_share') {
-                this._isScreenShareActive = true;
-                this.emit('screenShareStateChange', { isScreenShareActive: true });
-            }
-        };
-        localParticipant.on('trackPublished', handleTrackPublished);
-        localParticipant.on('trackUnpublished', handleTrackUnpublished);
-        localParticipant.on('trackMuted', handleTrackMuted);
-        localParticipant.on('trackUnmuted', handleTrackUnmuted);
-    }
-    /**
-     * Clean up event listeners
-     */
-    cleanupListeners() {
-        if (!this.room)
-            return;
-        // LiveKit handles cleanup automatically when participant is removed
-    }
-    /**
-     * Update screen share state from room
-     */
-    updateState() {
-        if (!this.room || this.room.state === 'disconnected') {
-            this._isScreenShareEnabled = false;
-            this._isScreenShareActive = false;
-            return;
-        }
-        const localParticipant = this.room.localParticipant;
-        this._isScreenShareEnabled = localParticipant.isScreenShareEnabled;
-        this._isScreenShareActive = localParticipant.isScreenShareEnabled;
-    }
-    /**
-     * Enable screen share
-     */
-    async enableScreenShare() {
-        if (!this.room) {
-            throw new Error('Room not initialized');
-        }
-        try {
-            // Use setScreenShareEnabled with options to include current tab
-            await this.room.localParticipant.setScreenShareEnabled(true, {
-                // @ts-ignore - selfBrowserSurface is a valid Chrome option but may not be in types
-                selfBrowserSurface: "include",
-                surfaceSwitching: "include",
-                systemAudio: "include",
-            });
-            this._isScreenShareEnabled = true;
-            this._isScreenShareActive = true;
-            this.emit('screenShareStateChange', { isScreenShareEnabled: true, isScreenShareActive: true });
-        }
-        catch (error) {
-            logger.error("Failed to enable screen share:", error);
-            throw error;
-        }
-    }
-    /**
-     * Disable screen share
-     */
-    async disableScreenShare() {
-        if (!this.room) {
-            throw new Error('Room not initialized');
-        }
-        try {
-            await this.room.localParticipant.setScreenShareEnabled(false);
-            this._isScreenShareEnabled = false;
-            this._isScreenShareActive = false;
-            this.emit('screenShareStateChange', { isScreenShareEnabled: false, isScreenShareActive: false });
-        }
-        catch (error) {
-            logger.error("Failed to disable screen share:", error);
-            throw error;
-        }
-    }
-    /**
-     * Toggle screen share
-     */
-    async toggleScreenShare() {
-        if (this._isScreenShareEnabled) {
-            await this.disableScreenShare();
-        }
-        else {
-            await this.enableScreenShare();
-        }
-    }
-    /**
-     * Enable screen share with audio
-     */
-    async enableScreenShareWithAudio() {
-        if (!this.room) {
-            throw new Error('Room not initialized');
-        }
-        try {
-            // Create screen tracks with audio enabled and include current tab
-            const tracks = await this.room.localParticipant.createScreenTracks({
-                audio: true,
-                // @ts-ignore - selfBrowserSurface is a valid Chrome option but may not be in types
-                selfBrowserSurface: "include",
-                surfaceSwitching: "include",
-                systemAudio: "include",
-            });
-            // Publish each track
-            tracks.forEach((track) => {
-                this.room.localParticipant.publishTrack(track);
-            });
-            this._isScreenShareEnabled = true;
-        }
-        catch (error) {
-            logger.error("Failed to enable screen share with audio:", error);
-            throw error;
-        }
-    }
-    /**
-     * Get screen share tracks
-     */
-    async getScreenShareTracks() {
-        if (!this.room) {
-            return [];
-        }
-        try {
-            const localParticipant = this.room.localParticipant;
-            const screenShareTracks = [];
-            // Get all published tracks
-            localParticipant.trackPublications.forEach((publication) => {
-                if (publication.source === 'screen_share' && publication.track) {
-                    screenShareTracks.push(publication.track);
-                }
-            });
-            return screenShareTracks;
-        }
-        catch (error) {
-            logger.error("Failed to get screen share tracks:", error);
-            throw error;
-        }
-    }
-    /**
-     * Reset state on disconnect
-     */
-    reset() {
-        this._isScreenShareEnabled = false;
-        this._isScreenShareActive = false;
-        this.emit('screenShareStateChange', {
-            isScreenShareEnabled: false,
-            isScreenShareActive: false
-        });
-    }
-}
-
-/**
- * Handles incoming messages from Convai
- * Processes various message types from the AI assistant and updates chat history
- */
-class MessageHandler extends EventEmitter {
-    constructor(room, latencyMonitor) {
-        super();
-        this.room = null;
-        this.chatMessages = [];
-        this.userTranscription = "";
-        this.isBotResponding = false;
-        this.isSpeaking = false;
-        this.latencyMonitor = null;
-        if (latencyMonitor) {
-            this.latencyMonitor = latencyMonitor;
-        }
-        if (room) {
-            this.setRoom(room);
-        }
-    }
-    /**
-     * Set the latency monitor
-     */
-    setLatencyMonitor(monitor) {
-        this.latencyMonitor = monitor;
-    }
-    /**
-     * Get current chat messages
-     */
-    getChatMessages() {
-        return this.chatMessages;
-    }
-    /**
-     * Get current user transcription
-     */
-    getUserTranscription() {
-        return this.userTranscription;
-    }
-    /**
-     * Get bot responding state
-     */
-    getIsBotResponding() {
-        return this.isBotResponding;
-    }
-    /**
-     * Get speaking state
-     */
-    getIsSpeaking() {
-        return this.isSpeaking;
-    }
-    /**
-     * Set the LiveKit room instance
-     */
-    setRoom(room) {
-        // Clean up previous room listeners
-        if (this.room) {
-            this.cleanupListeners();
-        }
-        this.room = room;
-        this.setupListeners();
-    }
-    /**
-     * Setup message listeners
-     */
-    setupListeners() {
-        if (!this.room)
-            return;
-        this.room.on(livekitClient.RoomEvent.DataReceived, this.handleDataReceived.bind(this));
-    }
-    /**
-     * Clean up message listeners
-     */
-    cleanupListeners() {
-        if (!this.room)
-            return;
-        this.room.off(livekitClient.RoomEvent.DataReceived, this.handleDataReceived.bind(this));
-    }
-    /**
-     * Handle incoming data message
-     */
-    handleDataReceived(payload, participant) {
-        try {
-            // Decode bytes to string
-            const decoder = new TextDecoder();
-            const messageString = decoder.decode(payload);
-            // Parse JSON
-            const messageData = JSON.parse(messageString);
-            // Extract and categorize messages for chat display
-            const timestamp = new Date().toISOString();
-            const messageId = `${messageData.type}-${Date.now()}-${Math.random()}`;
-            // Handle different message types
-            switch (messageData.type) {
-                // User text messages - Skip these, only allow user-transcription
-                case "user_text_message":
-                case "user-llm-text":
-                case "text-input":
-                case "user-input":
-                case "text-message":
-                case "chat-message":
-                case "input-text":
-                case "message":
-                    // Skip user text messages - only allow user-transcription
-                    break;
-                // Bot Ready - Bot is ready, connection should be true
-                case "bot-ready":
-                    this.emit("botReady");
-                    break;
-                // Bot LLM Started - Begin streaming response
-                case "bot-llm-started":
-                    this.isBotResponding = true;
-                    this.emit("botRespondingChange", true);
-                    // Mark any accumulated user message as final before starting bot response
-                    const lastMsg = this.chatMessages[this.chatMessages.length - 1];
-                    if (lastMsg &&
-                        lastMsg.type === "user-transcription" &&
-                        lastMsg.isFinal) {
-                        this.chatMessages[this.chatMessages.length - 1] = {
-                            ...lastMsg,
-                            isFinal: false,
-                        };
-                    }
-                    // Add initial streaming message to chat
-                    const streamingMessage = {
-                        id: messageId,
-                        type: "bot-llm-text",
-                        content: "",
-                        timestamp: timestamp,
-                        isFinal: true,
-                    };
-                    this.chatMessages.push(streamingMessage);
-                    this.emit("messagesChange", this.chatMessages);
-                    break;
-                // Bot LLM Text Messages - Streaming chunks
-                case "bot-llm-text":
-                    if (messageData.data?.text) {
-                        const newChunk = messageData.data.text;
-                        // Update the streaming message in chat
-                        const lastMessage = this.chatMessages[this.chatMessages.length - 1];
-                        if (lastMessage && lastMessage.isFinal) {
-                            this.chatMessages[this.chatMessages.length - 1] = {
-                                ...lastMessage,
-                                content: lastMessage.content + newChunk,
-                            };
-                        }
-                        else {
-                            // If no streaming message exists yet, create one
-                            const streamingMsg = {
-                                id: `${messageData.type}-${Date.now()}-${Math.random()}`,
-                                type: "bot-llm-text",
-                                content: newChunk,
-                                timestamp: new Date().toISOString(),
-                                isFinal: true,
-                            };
-                            this.chatMessages.push(streamingMsg);
-                        }
-                        this.emit("messagesChange", this.chatMessages);
-                    }
-                    break;
-                // Bot LLM Stopped - Complete streaming response
-                case "bot-llm-stopped":
-                    const lastBotMsg = this.chatMessages[this.chatMessages.length - 1];
-                    if (lastBotMsg && lastBotMsg.isFinal) {
-                        this.chatMessages[this.chatMessages.length - 1] = {
-                            ...lastBotMsg,
-                            isFinal: false,
-                        };
-                    }
-                    // Clear streaming state
-                    this.isBotResponding = false;
-                    this.emit("botRespondingChange", false);
-                    this.emit("messagesChange", this.chatMessages);
-                    break;
-                // User Transcription Messages
-                case "user-transcription":
-                    if (messageData.data?.text) {
-                        const messageContent = messageData.data.text;
-                        if (messageData.data?.final) {
-                            // Final transcription - accumulate in single bubble until bot responds
-                            const lastUserMsg = this.chatMessages[this.chatMessages.length - 1];
-                            // Start latency measurement for voice when user finishes speaking
-                            if (this.latencyMonitor) {
-                                this.latencyMonitor.startMeasurement("voice", messageContent);
-                            }
-                            // Check if last message is an accumulating user message (isFinal=true)
-                            if (lastUserMsg &&
-                                lastUserMsg.type === "user-transcription" &&
-                                lastUserMsg.isFinal === true) {
-                                // Accumulate: append new content to existing message with space
-                                const accumulatedContent = lastUserMsg.content.trim() + " " + messageContent.trim();
-                                this.chatMessages[this.chatMessages.length - 1] = {
-                                    ...lastUserMsg,
-                                    content: accumulatedContent,
-                                    timestamp: timestamp,
-                                };
-                            }
-                            else {
-                                // Start new accumulating message (isFinal=true means "still accumulating")
-                                const userMessage = {
-                                    id: messageId,
-                                    type: "user-transcription",
-                                    content: messageContent,
-                                    timestamp: timestamp,
-                                    isFinal: true,
-                                };
-                                this.chatMessages.push(userMessage);
-                            }
-                            this.emit("messagesChange", this.chatMessages);
-                            // Clear live transcription when final
-                            this.userTranscription = "";
-                            this.emit("userTranscriptionChange", "");
-                        }
-                        else {
-                            // Non-final transcription - show in input field
-                            this.userTranscription = messageContent;
-                            this.emit("userTranscriptionChange", messageContent);
-                        }
-                    }
-                    break;
-                // Bot Emotion Messages
-                case "bot-emotion":
-                    if (messageData.data?.emotion) {
-                        const emotionMessage = {
-                            id: messageId,
-                            type: "bot-emotion",
-                            content: `${messageData.data.emotion} (scale: ${messageData.data.scale || 1})`,
-                            timestamp,
-                        };
-                        this.chatMessages.push(emotionMessage);
-                        console.log("BotEmotions", emotionMessage);
-                        this.emit("messagesChange", this.chatMessages);
-                    }
-                    break;
-                // Bot Started Speaking
-                case "bot-started-speaking":
-                    this.isSpeaking = true;
-                    this.emit("speakingChange", true);
-                    break;
-                // Bot Stopped Speaking
-                case "bot-stopped-speaking":
-                    this.isSpeaking = false;
-                    this.emit("speakingChange", false);
-                    break;
-                // Action Response Messages
-                case "action-response":
-                    if (messageData.data?.actions) {
-                        const actionMessage = {
-                            id: messageId,
-                            type: "action",
-                            content: `Actions: ${messageData.data.actions.join(", ")}`,
-                            timestamp,
-                        };
-                        this.chatMessages.push(actionMessage);
-                        this.emit("messagesChange", this.chatMessages);
-                    }
-                    break;
-                // Behavior Tree Response Messages
-                case "behavior-tree-response":
-                    if (messageData.data?.narrative_section_id) {
-                        const behaviorMessage = {
-                            id: messageId,
-                            type: "behavior-tree",
-                            content: `Narrative Section: ${messageData.data.narrative_section_id}`,
-                            timestamp,
-                        };
-                        this.chatMessages.push(behaviorMessage);
-                        this.emit("messagesChange", this.chatMessages);
-                    }
-                    break;
-                // Server Message - Contains various data types like blendshapes
-                case "server-message":
-                    if (messageData.data) {
-                        const serverData = messageData.data;
-                        // Check if this is blendshape data
-                        if (serverData.type === "chunked-neurosync-blendshapes" &&
-                            serverData.blendshapes) {
-                            // Emit event for external listeners
-                            this.emit("blendshapes", serverData);
-                        }
-                        else {
-                            // Log other server message types
-                            logger.info("[MessageHandler] Server message:", {
-                                type: serverData.type,
-                                dataKeys: Object.keys(serverData),
-                            });
-                        }
-                    }
-                    break;
-                // Silently ignore other message types
-                case "moderation-response":
-                case "trigger-message":
-                case "update-template-keys":
-                case "update-dynamic-info":
-                case "interrupt-bot":
-                    break;
-            }
-        }
-        catch (error) {
-            logger.error("Failed to parse data message:", error);
-        }
-    }
-    /**
-     * Reset message state
-     */
-    reset() {
-        this.chatMessages = [];
-        this.userTranscription = "";
-        this.isBotResponding = false;
-        this.isSpeaking = false;
-        this.emit("messagesChange", this.chatMessages);
-        this.emit("userTranscriptionChange", "");
-        this.emit("botRespondingChange", false);
-        this.emit("speakingChange", false);
-    }
-}
-
-/**
- * Resolves the speaker ID based on the end user ID.
- *
- * - If endUserId is not provided (anonymous mode), returns null (no speaker ID sent to API)
- * - If endUserId is provided, calls Convai API to get or create a speaker ID for the user
- *
- * @param endUserId - The end user identifier (optional). If not provided, anonymous mode is used.
- * @param apiKey - Convai API key for authentication
- * @returns Promise resolving to the speaker ID or null if no endUserId provided
- */
-async function resolveSpeakerId(endUserId, apiKey) {
-    // Anonymous mode: No speaker ID (no persistent memory or analytics)
-    if (!endUserId) {
-        logger.info('Anonymous mode: No endUserId provided, speaker ID will not be sent');
-        return null;
-    }
-    // User tracking mode: Get or create speaker ID via Convai API (enables memory and analytics)
-    try {
-        const speakerId = await getOrCreateSpeakerId(endUserId, apiKey);
-        logger.info(`Resolved speaker ID: ${speakerId.substring(0, 8)}...`);
-        return speakerId;
-    }
-    catch (error) {
-        logger.error('Failed to resolve speaker ID:', error);
-        throw error;
-    }
-}
-/**
- * Gets or creates a speaker ID from Convai's speaker management API.
- * If the same endUserId is used multiple times, the same speaker ID is returned (idempotent).
- *
- * @param endUserId - The device or user identifier
- * @param apiKey - Convai API key for authentication
- * @returns Promise resolving to the speaker ID
- * @throws Error if API request fails
- */
-async function getOrCreateSpeakerId(endUserId, apiKey) {
-    const url = 'https://api.convai.com/user/speaker/new';
-    logger.info(`Requesting speaker ID for endUserId: ${endUserId.substring(0, 8)}...`);
-    try {
-        const response = await fetch(url, {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-                'CONVAI-API-KEY': apiKey,
-            },
-            body: JSON.stringify({
-                deviceId: endUserId,
-            }),
-        });
-        if (!response.ok) {
-            const errorText = await response.text();
-            throw new Error(`Speaker API request failed: ${response.status} ${response.statusText} - ${errorText}`);
-        }
-        const data = await response.json();
-        if (!data.speakerId) {
-            throw new Error('Speaker API did not return a speaker ID');
-        }
-        return data.speakerId;
-    }
-    catch (error) {
-        if (error instanceof Error) {
-            throw new Error(`Failed to get speaker ID: ${error.message}`);
-        }
-        throw new Error('Failed to get speaker ID: Unknown error');
-    }
-}
-
-/**
- * LatencyMonitor - Tracks and manages latency measurements
- * This is for dev/debugging purposes only
- */
-class LatencyMonitor extends EventEmitter {
-    constructor(enabled = false) {
-        super();
-        this.measurements = [];
-        this.pendingMeasurement = null;
-        this.maxMeasurements = 100; // Keep last 100 measurements
-        this.isEnabled = false;
-        this.isEnabled = enabled;
-    }
-    /**
-     * Enable latency monitoring
-     */
-    enable() {
-        this.isEnabled = true;
-        this.emit("enabledChange", true);
-    }
-    /**
-     * Disable latency monitoring
-     */
-    disable() {
-        this.isEnabled = false;
-        this.emit("enabledChange", false);
-    }
-    /**
-     * Check if monitoring is enabled
-     */
-    get enabled() {
-        return this.isEnabled;
-    }
-    /**
-     * Start a new latency measurement
-     */
-    startMeasurement(type, userMessage) {
-        if (!this.isEnabled)
-            return;
-        const id = `${type}-${Date.now()}-${Math.random()}`;
-        this.pendingMeasurement = {
-            id,
-            startTime: Date.now(),
-            type,
-            userMessage: userMessage?.substring(0, 50), // Keep first 50 chars
-        };
-    }
-    /**
-     * Complete the current measurement
-     */
-    endMeasurement() {
-        if (!this.isEnabled || !this.pendingMeasurement)
-            return;
-        const endTime = Date.now();
-        const latency = endTime - this.pendingMeasurement.startTime;
-        const measurement = {
-            id: this.pendingMeasurement.id,
-            startTime: this.pendingMeasurement.startTime,
-            endTime,
-            latency,
-            type: this.pendingMeasurement.type,
-            userMessage: this.pendingMeasurement.userMessage,
-        };
-        // Add to measurements array
-        this.measurements.push(measurement);
-        // Keep only the last N measurements
-        if (this.measurements.length > this.maxMeasurements) {
-            this.measurements.shift();
-        }
-        // Clear pending measurement
-        this.pendingMeasurement = null;
-        // Emit new measurement
-        this.emit("measurement", measurement);
-        this.emit("measurementsChange", this.measurements);
-    }
-    /**
-     * Cancel the current pending measurement
-     */
-    cancelMeasurement() {
-        this.pendingMeasurement = null;
-    }
-    /**
-     * Get all measurements
-     */
-    getMeasurements() {
-        return [...this.measurements];
-    }
-    /**
-     * Get the latest measurement
-     */
-    getLatestMeasurement() {
-        return this.measurements.length > 0
-            ? this.measurements[this.measurements.length - 1]
-            : null;
-    }
-    /**
-     * Get latency statistics
-     */
-    getStats() {
-        if (this.measurements.length === 0)
-            return null;
-        const latencies = this.measurements.map((m) => m.latency).sort((a, b) => a - b);
-        const sum = latencies.reduce((acc, val) => acc + val, 0);
-        const p95Index = Math.floor(latencies.length * 0.95);
-        return {
-            average: sum / latencies.length,
-            min: latencies[0],
-            max: latencies[latencies.length - 1],
-            median: latencies[Math.floor(latencies.length / 2)],
-            p95: latencies[p95Index],
-            count: latencies.length,
-        };
-    }
-    /**
-     * Clear all measurements
-     */
-    clear() {
-        this.measurements = [];
-        this.pendingMeasurement = null;
-        this.emit("measurementsChange", this.measurements);
-    }
-    /**
-     * Check if there's a pending measurement
-     */
-    get hasPendingMeasurement() {
-        return this.pendingMeasurement !== null;
-    }
-    /**
-     * Get pending measurement info
-     */
-    getPendingMeasurement() {
-        return this.pendingMeasurement ? { ...this.pendingMeasurement } : null;
-    }
-}
-
-/**
- * Main Convai client class for managing AI voice assistant connections
- * Provides complete interface for connecting to Convai's voice assistants,
- * managing real-time audio/video conversations, and handling messages.
- *
- * @example
- * ```typescript
- * import { ConvaiClient } from '@convai/web-sdk/core';
- *
- * // Recommended: Pass config to constructor
- * const client = new ConvaiClient({
- *   apiKey: 'your-api-key',
- *   characterId: 'your-character-id',
- *   endUserId: 'user-uuid', // Optional: enables memory & analytics
- *   enableVideo: true,
- * });
- *
- * // Listen for state changes
- * client.on('stateChange', (state) => {
- *   console.log('State:', state);
- * });
- *
- * // Connect (uses stored config from constructor)
- * await client.connect();
- *
- * // Send a message
- * client.sendUserTextMessage('Hello!');
- *
- * // Advanced: Override config or connect without constructor config
- * await client.connect({ apiKey: 'different-key', characterId: 'different-id' });
- *
- * // Disconnect and reconnect
- * await client.disconnect();
- * await client.reconnect();
- * ```
- */
-class ConvaiClient extends EventEmitter {
-    constructor(config) {
-        super();
-        this._connectionType = null;
-        this._apiKey = null;
-        this._characterId = null;
-        this._speakerId = null;
-        this._characterSessionId = "-1";
-        this._isBotReady = false;
-        this._participantSid = "";
-        this._storedConfig = null;
-        // Store config if provided
-        if (config) {
-            this._storedConfig = config;
-        }
-        // Initialize room
-        this._room = new livekitClient.Room();
-        // Initialize state
-        this._state = {
-            isConnected: false,
-            isConnecting: false,
-            isListening: false,
-            isThinking: false,
-            isSpeaking: false,
-            agentState: "disconnected",
-        };
-        // Default audio settings for optimal interruption handling
-        this._audioSettings = {
-            echoCancellation: true,
-            noiseSuppression: true,
-            autoGainControl: true,
-            sampleRate: 48000,
-            channelCount: 1,
-        };
-        // Initialize managers
-        this._audioManager = new AudioManager(this._room);
-        this._videoManager = new VideoManager(this._room);
-        this._screenShareManager = new ScreenShareManager(this._room);
-        this._latencyMonitor = new LatencyMonitor(false); // Disabled by default
-        this._messageHandler = new MessageHandler(this._room, this._latencyMonitor);
-        // Setup event listeners
-        this.setupEventListeners();
-    }
-    // Getters
-    get state() {
-        return { ...this._state };
-    }
-    get connectionType() {
-        return this._connectionType;
-    }
-    get apiKey() {
-        return this._apiKey;
-    }
-    get characterId() {
-        return this._characterId;
-    }
-    get speakerId() {
-        return this._speakerId;
-    }
-    get room() {
-        return this._room;
-    }
-    get chatMessages() {
-        return this._messageHandler.getChatMessages();
-    }
-    get userTranscription() {
-        return this._messageHandler.getUserTranscription();
-    }
-    get characterSessionId() {
-        return this._characterSessionId;
-    }
-    get isBotReady() {
-        return this._isBotReady;
-    }
-    get audioControls() {
-        return this._audioManager;
-    }
-    get videoControls() {
-        return this._videoManager;
-    }
-    get screenShareControls() {
-        return this._screenShareManager;
-    }
-    get latencyMonitor() {
-        return this._latencyMonitor;
-    }
-    // Convenience getters to match React hook's top-level reactive state
-    // These provide direct access without going through the control managers
-    /**
-     * Whether the user's microphone is currently muted
-     * Convenience getter - equivalent to audioControls.isAudioMuted
-     */
-    get isAudioMuted() {
-        return this._audioManager.isAudioMuted;
-    }
-    /**
-     * Whether the user's video is currently enabled
-     * Convenience getter - equivalent to videoControls.isVideoEnabled
-     */
-    get isVideoEnabled() {
-        return this._videoManager.isVideoEnabled;
-    }
-    /**
-     * Whether screen sharing is currently active
-     * Convenience getter - equivalent to screenShareControls.isScreenShareActive
-     */
-    get isScreenShareActive() {
-        return this._screenShareManager.isScreenShareActive;
-    }
-    /**
-     * Setup event listeners for room and managers
-     */
-    setupEventListeners() {
-        // Room event listeners
-        this._room.on(livekitClient.RoomEvent.Disconnected, this.handleDisconnected.bind(this));
-        this._room.on(livekitClient.RoomEvent.ConnectionStateChanged, this.handleConnectionStateChanged.bind(this));
-        // Message handler events
-        this._messageHandler.on("botReady", () => {
-            this._isBotReady = true;
-            this.updateState({ isConnected: true });
-            this.emit("botReady");
-        });
-        this._messageHandler.on("messagesChange", (messages) => {
-            this.emit("message", messages[messages.length - 1]);
-            this.emit("messagesChange", messages);
-        });
-        this._messageHandler.on("userTranscriptionChange", (transcription) => {
-            this.emit("userTranscriptionChange", transcription);
-        });
-        this._messageHandler.on("speakingChange", (isSpeaking) => {
-            this.updateState({ isSpeaking });
-            this.emit("speakingChange", isSpeaking);
-            // End latency measurement when bot starts speaking
-            if (isSpeaking) {
-                this._latencyMonitor.endMeasurement();
-            }
-        });
-        // Forward blendshapes events
-        this._messageHandler.on("blendshapes", (data) => {
-            this.emit("blendshapes", data);
-        });
-        this._messageHandler.on("botRespondingChange", (isResponding) => {
-            this.updateState({ isThinking: isResponding });
-        });
-        // Forward latency monitor events
-        this._latencyMonitor.on("measurement", (measurement) => {
-            this.emit("latencyMeasurement", measurement);
-        });
-    }
-    /**
-     * Handle room disconnection
-     */
-    handleDisconnected() {
-        this.updateState({
-            isConnected: false,
-            isConnecting: false,
-            isSpeaking: false,
-            isThinking: false,
-            isListening: false,
-        });
-        this._isBotReady = false;
-        this._messageHandler.reset();
-        this.emit("disconnect");
-    }
-    /**
-     * Handle connection state changes
-     */
-    handleConnectionStateChanged(state) {
-        if (state === "disconnected") {
-            this.updateState({
-                isConnected: false,
-                isConnecting: false,
-            });
-            this._isBotReady = false;
-            this._messageHandler.reset();
-        }
-        else if (state === "connected") {
-            this.updateState({
-                isConnected: true,
-                isConnecting: false,
-            });
-            this._isBotReady = false; // Wait for bot-ready message
-        }
-        else if (state === "connecting") {
-            this.updateState({
-                isConnecting: true,
-                isConnected: false,
-            });
-            this._isBotReady = false;
-        }
-    }
-    /**
-     * Update state and emit changes
-     */
-    updateState(updates) {
-        const oldState = { ...this._state };
-        this._state = { ...this._state, ...updates };
-        // Update agentState based on individual flags
-        if (!this._state.isConnected) {
-            this._state.agentState = "disconnected";
-        }
-        else if (this._state.isSpeaking) {
-            this._state.agentState = "speaking";
-        }
-        else if (this._state.isThinking) {
-            this._state.agentState = "thinking";
-        }
-        else if (this._state.isListening) {
-            this._state.agentState = "listening";
-        }
-        else {
-            this._state.agentState = "connected";
-        }
-        // Emit state change if changed
-        if (JSON.stringify(oldState) !== JSON.stringify(this._state)) {
-            this.emit("stateChange", this._state);
-        }
-    }
-    /**
-     * Connect to a Convai character
-     */
-    async connect(config) {
-        // Use provided config or stored config
-        const finalConfig = config || this._storedConfig;
-        if (!finalConfig) {
-            throw new Error("No configuration provided. Pass config to connect() or store it in the client");
-        }
-        // Store config for reconnection
-        this._storedConfig = finalConfig;
-        // Add default URL if not provided
-        const configWithDefaults = {
-            // url: "https://realtime-api.convai.com",
-            url: "https://realtime-api-stg.convai.com",
-            ...finalConfig,
-        };
-        if (!configWithDefaults.apiKey || !configWithDefaults.characterId) {
-            throw new Error("apiKey and characterId are required");
-        }
-        this.updateState({ isConnecting: true });
-        try {
-            // Store connection config
-            this._apiKey = configWithDefaults.apiKey;
-            this._characterId = configWithDefaults.characterId;
-            // Resolve speaker ID based on endUserId
-            if (configWithDefaults.endUserId) {
-                logger.info(`Resolving speaker ID for endUserId: ${configWithDefaults.endUserId}`);
-            }
-            else {
-                logger.info("Connecting in anonymous mode (no endUserId provided)");
-            }
-            const resolvedSpeakerId = await resolveSpeakerId(configWithDefaults.endUserId, configWithDefaults.apiKey);
-            this._speakerId = resolvedSpeakerId;
-            if (resolvedSpeakerId) {
-                logger.info(`Speaker ID resolved: ${resolvedSpeakerId.substring(0, 8)}...`);
-            }
-            else {
-                logger.info("No speaker ID - connecting without persistent memory");
-            }
-            // Determine connection type based on enableVideo
-            const connType = configWithDefaults.enableVideo ? "video" : "audio";
-            this._connectionType = connType;
-            // Prepare request body with required parameters
-            const requestBody = {
-                character_id: configWithDefaults.characterId,
-                ...(resolvedSpeakerId && { speaker_id: resolvedSpeakerId }),
-                transport: "livekit",
-                connection_type: connType,
-                use_dynamic_pipeline: false,
-                blendshape_provider: configWithDefaults.blendshapeProvider || "neurosync",
-                blendshape_config: {
-                    enable_chunking: true,
-                    format: configWithDefaults.blendshapeConfig?.format || "mha",
-                    output_fps: 60,
-                },
-                llm_provider: "dynamic",
-                default_tts_enabled: configWithDefaults.ttsEnabled !== undefined
-                    ? configWithDefaults.ttsEnabled
-                    : true,
-                ...(this._characterSessionId &&
-                    this._characterSessionId !== "-1" && {
-                    character_session_id: this._characterSessionId,
-                }),
-                ...(configWithDefaults.actionConfig && {
-                    action_config: configWithDefaults.actionConfig,
-                }),
-            };
-            // Call Core Service API
-            const response = await fetch(`${configWithDefaults.url}/connect`, {
-                method: "POST",
-                headers: {
-                    "x-api-key": configWithDefaults.apiKey,
-                    "Content-Type": "application/json",
-                },
-                body: JSON.stringify(requestBody),
-            });
-            if (!response.ok) {
-                const errorText = await response.text();
-                logger.error("API Error Response:", {
-                    status: response.status,
-                    statusText: response.statusText,
-                    body: errorText,
-                });
-                let errorMessage = `HTTP error! status: ${response.status}`;
-                try {
-                    const errorData = JSON.parse(errorText);
-                    if (errorData.message) {
-                        errorMessage = errorData.message;
-                    }
-                    else if (errorData.error) {
-                        errorMessage = errorData.error;
-                    }
-                    else if (errorData.detail) {
-                        errorMessage = errorData.detail;
-                    }
-                }
-                catch (e) {
-                    if (errorText) {
-                        errorMessage = `${errorMessage}: ${errorText}`;
-                    }
-                }
-                throw new Error(errorMessage);
-            }
-            const connectionData = await response.json();
-            // Capture character_session_id from connection response
-            if (connectionData.character_session_id) {
-                this._characterSessionId = connectionData.character_session_id;
-            }
-            // Connect to LiveKit room
-            await this._room.connect(connectionData.room_url, connectionData.token, {
-                rtcConfig: {
-                    iceTransportPolicy: "relay",
-                },
-            });
-            // Enable microphone only if startWithAudioOn is true (default: false)
-            // If false, microphone stays off until user enables it via audioControls
-            if (configWithDefaults.startWithAudioOn) {
-                await this._room.localParticipant.setMicrophoneEnabled(true, {
-                    echoCancellation: this._audioSettings.echoCancellation,
-                    noiseSuppression: this._audioSettings.noiseSuppression,
-                    autoGainControl: this._audioSettings.autoGainControl,
-                    sampleRate: this._audioSettings.sampleRate,
-                    channelCount: this._audioSettings.channelCount,
-                });
-            }
-            // Enable camera only if enableVideo is true AND startWithVideoOn is true
-            if (configWithDefaults.enableVideo &&
-                configWithDefaults.startWithVideoOn) {
-                await this._room.localParticipant.setCameraEnabled(true);
-            }
-            // Ensure audio manager mirrors the actual microphone permission state
-            this._audioManager.syncStateFromRoom({ emit: true });
-            // Capture participant SID
-            this._participantSid = this._room.localParticipant.sid;
-            this.updateState({
-                isConnected: true,
-                isConnecting: false,
-            });
-            this.emit("connect");
-        }
-        catch (error) {
-            logger.error("Connection failed:", error);
-            this.updateState({
-                isConnected: false,
-                isConnecting: false,
-            });
-            this.emit("error", error);
-            throw error;
-        }
-    }
-    /**
-     * Disconnect from the current character session
-     */
-    async disconnect() {
-        if (this._room && this._room.state !== "disconnected") {
-            try {
-                await this._room.disconnect();
-                this.resetConnectionState();
-            }
-            catch (error) {
-                // Handle disconnect errors gracefully
-                if (!(error instanceof Error && error.message.includes("disconnect"))) {
-                    logger.error("Disconnect error:", error);
-                }
-                this.resetConnectionState();
-            }
-        }
-    }
-    /**
-     * Reset connection state
-     */
-    resetConnectionState() {
-        this.updateState({
-            isConnected: false,
-            isConnecting: false,
-            isSpeaking: false,
-            isThinking: false,
-            isListening: false,
-        });
-        this._isBotReady = false;
-        this._connectionType = null;
-        this._apiKey = null;
-        this._characterId = null;
-        this._speakerId = null;
-        this._messageHandler.reset();
-        this._audioManager.reset();
-        this._videoManager.reset();
-        this._screenShareManager.reset();
-    }
-    /**
-     * Reconnect - disconnect and connect again using stored config
-     */
-    async reconnect() {
-        if (!this._storedConfig) {
-            throw new Error("No stored config available for reconnection");
-        }
-        await this.disconnect();
-        await this.connect(this._storedConfig);
-    }
-    /**
-     * Reset the session ID to start a new conversation
-     */
-    resetSession() {
-        this._characterSessionId = "-1";
-        this._messageHandler.reset();
-    }
-    /**
-     * Send a text message to the character
-     */
-    sendUserTextMessage(text) {
-        if (!this._room ||
-            this._room.state === "disconnected" ||
-            !this._room.localParticipant) {
-            logger.warn("Cannot send message: not connected");
-            return;
-        }
-        if (!text || !text.trim()) {
-            return;
-        }
-        try {
-            // Start latency measurement for text message
-            this._latencyMonitor.startMeasurement("text", text.trim());
-            const message = {
-                type: "user_text_message",
-                data: {
-                    text: text.trim(),
-                    participant_sid: this._participantSid || this._room.localParticipant.sid,
-                },
-            };
-            const encodedData = new TextEncoder().encode(JSON.stringify(message));
-            this._room.localParticipant.publishData(encodedData, {
-                reliable: true,
-            });
-        }
-        catch (error) {
-            logger.error("Failed to send user text message:", error);
-            // Cancel latency measurement on error
-            this._latencyMonitor.cancelMeasurement();
-            throw error;
-        }
-    }
-    /**
-     * Send a trigger message to invoke specific character actions
-     */
-    sendTriggerMessage(triggerName, triggerMessage) {
-        if (this._room && this._room.localParticipant) {
-            const message = {
-                type: "trigger-message",
-                data: {
-                    ...(triggerName && { trigger_name: triggerName }),
-                    ...(triggerMessage && { trigger_message: triggerMessage }),
-                    participant_sid: this._participantSid || this._room.localParticipant.sid,
-                },
-            };
-            const encodedData = new TextEncoder().encode(JSON.stringify(message));
-            this._room.localParticipant.publishData(encodedData, {
-                reliable: true,
-            });
-        }
-    }
-    /**
-     * Send an interrupt message to stop the bot's current response
-     */
-    sendInterruptMessage() {
-        if (!this._room ||
-            this._room.state === "disconnected" ||
-            !this._room.localParticipant) {
-            logger.warn("Cannot send interrupt message: not connected");
-            return;
-        }
-        try {
-            const message = {
-                type: "interrupt-bot",
-                data: {
-                    participant_sid: this._participantSid || this._room.localParticipant.sid,
-                },
-            };
-            const encodedData = new TextEncoder().encode(JSON.stringify(message));
-            this._room.localParticipant.publishData(encodedData, {
-                reliable: true,
-            });
-            logger.info("Interrupt message sent");
-        }
-        catch (error) {
-            logger.error("Failed to send interrupt message:", error);
-            throw error;
-        }
-    }
-    /**
-     * Update template keys in the character's context
-     */
-    updateTemplateKeys(templateKeys) {
-        if (this._room &&
-            this._room.localParticipant &&
-            Object.keys(templateKeys).length > 0) {
-            const message = {
-                type: "update-template-keys",
-                data: {
-                    template_keys: templateKeys,
-                    participant_sid: this._participantSid || this._room.localParticipant.sid,
-                },
-            };
-            const encodedData = new TextEncoder().encode(JSON.stringify(message));
-            this._room.localParticipant.publishData(encodedData, {
-                reliable: true,
-            });
-        }
-    }
-    /**
-     * Update dynamic information about the current context
-     */
-    updateDynamicInfo(dynamicInfo) {
-        if (this._room && this._room.localParticipant && dynamicInfo.text?.trim()) {
-            const message = {
-                type: "update-dynamic-info",
-                data: {
-                    dynamic_info: {
-                        text: dynamicInfo.text.trim(),
-                    },
-                    participant_sid: this._participantSid || this._room.localParticipant.sid,
-                },
-            };
-            const encodedData = new TextEncoder().encode(JSON.stringify(message));
-            this._room.localParticipant.publishData(encodedData, {
-                reliable: true,
-            });
-        }
-    }
-    /**
-     * Toggle text-to-speech on or off
-     */
-    toggleTts(enabled) {
-        if (!this._room ||
-            this._room.state === "disconnected" ||
-            !this._room.localParticipant) {
-            return;
-        }
-        try {
-            const message = {
-                type: "tts-toggle",
-                data: {
-                    enabled: enabled,
-                },
-            };
-            const encodedData = new TextEncoder().encode(JSON.stringify(message));
-            this._room.localParticipant.publishData(encodedData, {
-                reliable: true,
-            });
-        }
-        catch (error) {
-            logger.error("Failed to toggle TTS:", error);
-            throw error;
-        }
-    }
-}
-
-exports.AudioManager = AudioManager;
-exports.ConvaiClient = ConvaiClient;
-exports.EventEmitter = EventEmitter;
-exports.MessageHandler = MessageHandler;
-exports.ScreenShareManager = ScreenShareManager;
-exports.VideoManager = VideoManager;