@aether-stack-dev/client-sdk 1.0.0 → 1.1.1

package/dist/react.js

@@ -2,7 +2,6 @@
 
 var react = require('react');
 var eventemitter3 = require('eventemitter3');
-var supabaseJs = require('@supabase/supabase-js');
 var jsxRuntime = require('react/jsx-runtime');
 var THREE = require('three');
 var GLTFLoader_js = require('three/examples/jsm/loaders/GLTFLoader.js');
@@ -27,2031 +26,6 @@ function _interopNamespaceDefault(e) {
 
 var THREE__namespace = /*#__PURE__*/_interopNamespaceDefault(THREE);
 
-class WebRTCManager extends eventemitter3.EventEmitter {
-    constructor(config) {
-        super();
-        this.localStream = null;
-        this.config = config;
-    }
-    async initialize() {
-        this.emit('initialized');
-    }
-    async getStats() {
-        return null;
-    }
-    async getUserMedia() {
-        const constraints = {
-            audio: this.config.enableAudio !== false ? {
-                echoCancellation: this.config.audio?.echoCancellation ?? true,
-                noiseSuppression: this.config.audio?.noiseSuppression ?? true,
-                autoGainControl: this.config.audio?.autoGainControl ?? true
-            } : false
-        };
-        return navigator.mediaDevices.getUserMedia(constraints);
-    }
-    async addLocalStream(stream) {
-        this.localStream = stream;
-        this.emit('localStreamAdded', stream);
-    }
-    removeLocalStream(streamId) {
-        if (this.localStream) {
-            this.localStream.getTracks().forEach(track => {
-                if (track.id === streamId)
-                    track.stop();
-            });
-        }
-    }
-    getLocalStreams() {
-        if (!this.localStream)
-            return [];
-        return this.localStream.getTracks().map(track => ({
-            id: track.id,
-            kind: track.kind,
-            active: track.enabled,
-            track
-        }));
-    }
-    getRemoteStreams() {
-        return [];
-    }
-    async getMediaDevices() {
-        return navigator.mediaDevices.enumerateDevices();
-    }
-    async switchAudioInput(deviceId) {
-        if (this.localStream) {
-            this.localStream.getAudioTracks().forEach(track => track.stop());
-        }
-        const stream = await navigator.mediaDevices.getUserMedia({
-            audio: { deviceId: { exact: deviceId } }
-        });
-        this.localStream = stream;
-        this.emit('localStreamAdded', stream);
-    }
-    muteAudio() {
-        if (this.localStream) {
-            this.localStream.getAudioTracks().forEach(track => { track.enabled = false; });
-        }
-    }
-    unmuteAudio() {
-        if (this.localStream) {
-            this.localStream.getAudioTracks().forEach(track => { track.enabled = true; });
-        }
-    }
-    muteVideo() {
-        if (this.localStream) {
-            this.localStream.getVideoTracks().forEach(track => { track.enabled = false; });
-        }
-    }
-    unmuteVideo() {
-        if (this.localStream) {
-            this.localStream.getVideoTracks().forEach(track => { track.enabled = true; });
-        }
-    }
-    async createOffer() {
-        console.warn('WebRTC is deprecated. Use WebSocket-based AStackCSRClient instead.');
-        return { type: 'offer', sdp: '' };
-    }
-    async createAnswer(remoteSdp) {
-        console.warn('WebRTC is deprecated. Use WebSocket-based AStackCSRClient instead.');
-        return { type: 'answer', sdp: '' };
-    }
-    async handleAnswer(answer) {
-        console.warn('WebRTC is deprecated. Use WebSocket-based AStackCSRClient instead.');
-    }
-    async addIceCandidate(candidate) {
-        console.warn('WebRTC is deprecated. Use WebSocket-based AStackCSRClient instead.');
-    }
-    async close() {
-        if (this.localStream) {
-            this.localStream.getTracks().forEach(track => track.stop());
-            this.localStream = null;
-        }
-        this.emit('closed');
-    }
-}
-
-class AStackError extends Error {
-    constructor(message, code) {
-        super(message);
-        this.name = 'AStackError';
-        this.code = code;
-    }
-}
-const ErrorCodes = {
-    INVALID_API_KEY: 'INVALID_API_KEY',
-    INVALID_TOKEN: 'INVALID_TOKEN',
-    AUTHENTICATION_FAILED: 'AUTHENTICATION_FAILED',
-    SESSION_EXPIRED: 'SESSION_EXPIRED',
-    SESSION_CREATION_FAILED: 'SESSION_CREATION_FAILED',
-    CONNECTION_LOST: 'CONNECTION_LOST',
-    SIGNALING_ERROR: 'SIGNALING_ERROR',
-    NETWORK_ERROR: 'NETWORK_ERROR',
-    MEDIA_ACCESS_DENIED: 'MEDIA_ACCESS_DENIED',
-    AUDIO_ERROR: 'AUDIO_ERROR',
-    RATE_LIMIT_EXCEEDED: 'RATE_LIMIT_EXCEEDED',
-    INSUFFICIENT_CREDITS: 'INSUFFICIENT_CREDITS',
-    BILLING_ERROR: 'BILLING_ERROR'
-};
-
-class SupabaseSignalingClient extends eventemitter3.EventEmitter {
-    constructor(config) {
-        super();
-        this.channel = null;
-        this.sessionId = null;
-        this.channelName = null;
-        this.wsToken = null;
-        this.channelId = null;
-        this.connected = false;
-        this.reconnectAttempts = 0;
-        this.heartbeatInterval = null;
-        this.config = config;
-        this.maxReconnectAttempts = config.maxRetries || 3;
-        this.reconnectDelay = config.reconnectDelay || 1000;
-        this.supabase = supabaseJs.createClient(config.supabaseUrl || process.env.NEXT_PUBLIC_SUPABASE_URL || '', config.supabaseAnonKey || process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY || '', {
-            realtime: {
-                params: {
-                    eventsPerSecond: 10
-                }
-            }
-        });
-    }
-    async connect(sessionId, channelName, wsToken) {
-        this.sessionId = sessionId;
-        this.channelName = channelName;
-        this.wsToken = wsToken;
-        return new Promise(async (resolve, reject) => {
-            try {
-                const { data: channelData, error } = await this.supabase
-                    .from('signaling_channels')
-                    .select('id')
-                    .eq('channel_name', channelName)
-                    .eq('ws_token', wsToken)
-                    .single();
-                if (error || !channelData) {
-                    throw new AStackError('Invalid channel credentials', ErrorCodes.SIGNALING_ERROR);
-                }
-                this.channelId = channelData.id;
-                this.channel = this.supabase.channel(channelName);
-                this.channel
-                    .on('postgres_changes', {
-                    event: 'INSERT',
-                    schema: 'public',
-                    table: 'signaling_messages',
-                    filter: `channel_id=eq.${this.channelId}`
-                }, (payload) => {
-                    this.handleSignalingMessage(payload.new);
-                })
-                    .on('presence', { event: 'sync' }, () => {
-                    const state = this.channel?.presenceState();
-                    this.handlePresenceSync(state);
-                })
-                    .on('presence', { event: 'join' }, ({ key, newPresences }) => {
-                    this.emit('userJoined', { key, presences: newPresences });
-                })
-                    .on('presence', { event: 'leave' }, ({ key, leftPresences }) => {
-                    this.emit('userLeft', { key, presences: leftPresences });
-                })
-                    .subscribe(async (status) => {
-                    if (status === 'SUBSCRIBED') {
-                        this.connected = true;
-                        this.reconnectAttempts = 0;
-                        await this.updateChannelStatus(true);
-                        await this.channel.track({
-                            user_type: 'client',
-                            user_id: sessionId,
-                            status: 'online',
-                            last_seen: new Date().toISOString(),
-                            metadata: {
-                                userAgent: navigator.userAgent,
-                                capabilities: {
-                                    audio: this.config.enableAudio !== false,
-                                    video: this.config.enableVideo === true,
-                                    text: this.config.enableText !== false
-                                }
-                            }
-                        });
-                        this.startHeartbeat();
-                        this.emit('sessionJoined', { sessionId, channelName });
-                        resolve();
-                    }
-                    else if (status === 'CHANNEL_ERROR') {
-                        reject(new AStackError('Failed to subscribe to signaling channel', ErrorCodes.SIGNALING_ERROR));
-                    }
-                });
-            }
-            catch (error) {
-                reject(new AStackError(`Failed to connect to signaling: ${error}`, ErrorCodes.SIGNALING_ERROR));
-            }
-        });
-    }
-    async handleSignalingMessage(message) {
-        if (message.sender_type === 'client') {
-            return;
-        }
-        switch (message.message_type) {
-            case 'audio':
-                this.emit('audioResponse', message.payload);
-                break;
-            case 'text':
-                this.emit('textResponse', message.payload);
-                break;
-            case 'control':
-                this.emit('controlMessage', message.payload);
-                break;
-            case 'ready':
-                this.emit('workerReady', message.payload);
-                break;
-            case 'error':
-                this.emit('error', new AStackError(message.payload.message || 'Worker error', ErrorCodes.SIGNALING_ERROR));
-                break;
-        }
-    }
-    handlePresenceSync(state) {
-        if (!state)
-            return;
-        const presences = Object.values(state);
-        const workerPresent = presences.some((presence) => presence.user_type === 'worker' && presence.status === 'online');
-        if (workerPresent) {
-            this.emit('workerConnected');
-        }
-        else {
-            this.emit('workerDisconnected');
-        }
-    }
-    async updateChannelStatus(connected) {
-        if (!this.channelId)
-            return;
-        try {
-            await this.supabase
-                .from('signaling_channels')
-                .update({ client_connected: connected })
-                .eq('id', this.channelId);
-        }
-        catch (error) { }
-    }
-    async sendText(text) {
-        await this.sendSignalingMessage('text', { text });
-    }
-    async sendAudio(audioData, metadata) {
-        await this.sendSignalingMessage('audio', { audio: audioData, ...metadata });
-    }
-    async sendControl(action, data) {
-        await this.sendSignalingMessage('control', { action, ...data });
-    }
-    async sendSignalingMessage(messageType, payload) {
-        if (!this.channelId || !this.connected) {
-            throw new AStackError('Not connected to signaling channel', ErrorCodes.SIGNALING_ERROR);
-        }
-        try {
-            const { error } = await this.supabase
-                .from('signaling_messages')
-                .insert({
-                channel_id: this.channelId,
-                sender_type: 'client',
-                message_type: messageType,
-                payload
-            });
-            if (error) {
-                throw new AStackError(`Failed to send ${messageType}: ${error.message}`, ErrorCodes.SIGNALING_ERROR);
-            }
-        }
-        catch (error) {
-            throw error;
-        }
-    }
-    sendTextMessage(text) {
-        this.sendText(text).catch(() => { });
-    }
-    sendAudioData(audioBlob) {
-        const reader = new FileReader();
-        reader.onload = () => {
-            const base64 = reader.result.split(',')[1];
-            this.sendAudio(base64).catch(() => { });
-        };
-        reader.readAsDataURL(audioBlob);
-    }
-    startHeartbeat() {
-        if (this.heartbeatInterval) {
-            clearInterval(this.heartbeatInterval);
-        }
-        const interval = this.config.heartbeatInterval || 30000;
-        this.heartbeatInterval = setInterval(async () => {
-            if (this.channel && this.connected) {
-                try {
-                    await this.channel.track({
-                        user_type: 'client',
-                        user_id: this.sessionId,
-                        status: 'online',
-                        last_seen: new Date().toISOString()
-                    });
-                }
-                catch (error) { }
-            }
-        }, interval);
-    }
-    stopHeartbeat() {
-        if (this.heartbeatInterval) {
-            clearInterval(this.heartbeatInterval);
-            this.heartbeatInterval = null;
-        }
-    }
-    async attemptReconnect() {
-        if (this.reconnectAttempts >= this.maxReconnectAttempts) {
-            this.emit('error', new AStackError('Maximum reconnection attempts reached', ErrorCodes.CONNECTION_LOST));
-            return;
-        }
-        this.reconnectAttempts++;
-        const delay = this.reconnectDelay * Math.pow(2, this.reconnectAttempts - 1);
-        this.emit('reconnecting', this.reconnectAttempts);
-        setTimeout(async () => {
-            if (!this.connected && this.sessionId && this.channelName && this.wsToken) {
-                try {
-                    await this.connect(this.sessionId, this.channelName, this.wsToken);
-                    this.emit('reconnected');
-                }
-                catch (error) {
-                    this.attemptReconnect();
-                }
-            }
-        }, delay);
-    }
-    async leaveSession() {
-        if (this.channel) {
-            try {
-                await this.channel.untrack();
-                await this.updateChannelStatus(false);
-            }
-            catch (error) { }
-        }
-    }
-    isConnected() {
-        return this.connected;
-    }
-    getSessionId() {
-        return this.sessionId;
-    }
-    async disconnect() {
-        this.connected = false;
-        this.stopHeartbeat();
-        if (this.channel) {
-            await this.leaveSession();
-            await this.channel.unsubscribe();
-            this.channel = null;
-        }
-        this.removeAllListeners();
-    }
-}
-
-class SessionManager {
-    constructor(apiEndpoint, sessionExpirationWarning = 1, onSessionExpiring) {
-        this.sessionCredentials = null;
-        this.workerInfo = null;
-        this.expirationTimer = null;
-        this.apiEndpoint = apiEndpoint;
-        this.sessionExpirationWarning = sessionExpirationWarning;
-        this.onSessionExpiring = onSessionExpiring;
-    }
-    async createSession(request) {
-        try {
-            const response = await fetch(`${this.apiEndpoint}/functions/v1/session`, {
-                method: 'POST',
-                headers: {
-                    'Content-Type': 'application/json',
-                    'Authorization': `Bearer ${request.apiKey}`
-                },
-                body: JSON.stringify({
-                    organizationId: request.organizationId,
-                    endUserId: request.endUserId,
-                    metadata: request.metadata,
-                    workerPreferences: request.workerPreferences
-                })
-            });
-            if (!response.ok) {
-                const errorData = await response.json().catch(() => ({ error: 'Unknown error' }));
-                if (response.status === 401) {
-                    throw new AStackError('Invalid API key', ErrorCodes.INVALID_API_KEY);
-                }
-                else if (response.status === 429) {
-                    throw new AStackError('Rate limit exceeded', ErrorCodes.RATE_LIMIT_EXCEEDED);
-                }
-                else if (response.status === 402) {
-                    throw new AStackError('Insufficient credits', ErrorCodes.INSUFFICIENT_CREDITS);
-                }
-                throw new AStackError(errorData.error || 'Session creation failed', ErrorCodes.SESSION_CREATION_FAILED);
-            }
-            const data = await response.json();
-            const expiresAt = new Date(Date.now() + (data.expiresIn * 1000));
-            this.sessionCredentials = {
-                sessionId: data.sessionId,
-                wsToken: data.wsToken,
-                channelName: data.channelName,
-                workerUrl: data.workerUrl,
-                expiresAt
-            };
-            if (data.workerInfo) {
-                this.workerInfo = data.workerInfo;
-            }
-            this.scheduleExpirationWarning();
-            return this.sessionCredentials;
-        }
-        catch (error) {
-            if (error instanceof AStackError) {
-                throw error;
-            }
-            throw new AStackError(`Failed to create session: ${error instanceof Error ? error.message : 'Unknown error'}`, ErrorCodes.SESSION_CREATION_FAILED);
-        }
-    }
-    async renewSession(apiKey) {
-        if (!this.sessionCredentials) {
-            throw new AStackError('No active session to renew', ErrorCodes.SESSION_EXPIRED);
-        }
-        const request = {
-            apiKey,
-            organizationId: this.sessionCredentials.sessionId.split('-')[0],
-            endUserId: undefined,
-            metadata: { previousSessionId: this.sessionCredentials.sessionId }
-        };
-        return this.createSession(request);
-    }
-    scheduleExpirationWarning() {
-        if (this.expirationTimer) {
-            clearTimeout(this.expirationTimer);
-        }
-        if (!this.sessionCredentials || !this.onSessionExpiring) {
-            return;
-        }
-        const now = Date.now();
-        const expirationTime = this.sessionCredentials.expiresAt.getTime();
-        const warningTime = expirationTime - (this.sessionExpirationWarning * 60 * 1000);
-        if (warningTime > now) {
-            this.expirationTimer = setTimeout(() => {
-                if (this.onSessionExpiring && this.sessionCredentials) {
-                    const minutesRemaining = Math.floor((this.sessionCredentials.expiresAt.getTime() - Date.now()) / 60000);
-                    this.onSessionExpiring(minutesRemaining);
-                }
-            }, warningTime - now);
-        }
-    }
-    getCredentials() {
-        return this.sessionCredentials;
-    }
-    isSessionValid() {
-        if (!this.sessionCredentials) {
-            return false;
-        }
-        return this.sessionCredentials.expiresAt.getTime() > Date.now();
-    }
-    getTimeUntilExpiration() {
-        if (!this.sessionCredentials) {
-            return 0;
-        }
-        const remaining = this.sessionCredentials.expiresAt.getTime() - Date.now();
-        return Math.max(0, remaining);
-    }
-    clearSession() {
-        this.sessionCredentials = null;
-        this.workerInfo = null;
-        if (this.expirationTimer) {
-            clearTimeout(this.expirationTimer);
-            this.expirationTimer = null;
-        }
-    }
-    getWorkerInfo() {
-        return this.workerInfo;
-    }
-    destroy() {
-        this.clearSession();
-    }
-}
-
-class BillingMonitor {
-    constructor(apiEndpoint, apiKey) {
-        this.apiEndpoint = apiEndpoint;
-        this.apiKey = apiKey;
-        this.updateCallbacks = [];
-        this.alertCallbacks = [];
-        this.warningThresholds = {
-            creditBalance: 10, // Warn when credits drop below 10
-            usagePercentage: 80 // Warn when usage reaches 80% of rate limit
-        };
-    }
-    async fetchBillingInfo() {
-        try {
-            const response = await fetch(`${this.apiEndpoint}/billing/info`, {
-                headers: {
-                    'Authorization': `Bearer ${this.apiKey}`,
-                    'Content-Type': 'application/json'
-                }
-            });
-            if (!response.ok) {
-                throw new Error(`Failed to fetch billing info: ${response.statusText}`);
-            }
-            const info = await response.json();
-            this.updateBillingInfo(info);
-            return info;
-        }
-        catch (error) {
-            throw error;
-        }
-    }
-    updateBillingInfo(info) {
-        const previousInfo = this.billingInfo;
-        this.billingInfo = info;
-        this.updateCallbacks.forEach(callback => callback(info));
-        this.checkForAlerts(info, previousInfo);
-    }
-    checkForAlerts(current, previous) {
-        if (current.creditBalance < this.warningThresholds.creditBalance) {
-            this.triggerAlert({
-                type: 'low_balance',
-                details: {
-                    currentBalance: current.creditBalance,
-                    threshold: this.warningThresholds.creditBalance
-                }
-            });
-        }
-        const usagePercentage = (current.currentUsage / current.rateLimit) * 100;
-        if (usagePercentage >= this.warningThresholds.usagePercentage) {
-            this.triggerAlert({
-                type: 'limit_exceeded',
-                details: {
-                    currentUsage: current.currentUsage,
-                    rateLimit: current.rateLimit,
-                    percentage: usagePercentage
-                }
-            });
-        }
-        if (previous && previous.creditBalance - current.creditBalance > 100) {
-            this.triggerAlert({
-                type: 'low_balance',
-                details: {
-                    previousBalance: previous.creditBalance,
-                    currentBalance: current.creditBalance,
-                    spent: previous.creditBalance - current.creditBalance
-                }
-            });
-        }
-    }
-    triggerAlert(alert) {
-        this.alertCallbacks.forEach(callback => callback(alert));
-    }
-    startMonitoring(intervalMs = 60000) {
-        this.stopMonitoring();
-        this.fetchBillingInfo().catch(() => { });
-        this.checkInterval = setInterval(() => {
-            this.fetchBillingInfo().catch(() => { });
-        }, intervalMs);
-    }
-    stopMonitoring() {
-        if (this.checkInterval) {
-            clearInterval(this.checkInterval);
-            this.checkInterval = undefined;
-        }
-    }
-    onUpdate(callback) {
-        this.updateCallbacks.push(callback);
-    }
-    onAlert(callback) {
-        this.alertCallbacks.push(callback);
-    }
-    removeUpdateCallback(callback) {
-        this.updateCallbacks = this.updateCallbacks.filter(cb => cb !== callback);
-    }
-    removeAlertCallback(callback) {
-        this.alertCallbacks = this.alertCallbacks.filter(cb => cb !== callback);
-    }
-    getCurrentBillingInfo() {
-        return this.billingInfo;
-    }
-    setWarningThresholds(thresholds) {
-        this.warningThresholds = { ...this.warningThresholds, ...thresholds };
-    }
-    async checkRateLimit() {
-        const info = await this.fetchBillingInfo();
-        return info.currentUsage < info.rateLimit;
-    }
-    destroy() {
-        this.stopMonitoring();
-        this.updateCallbacks = [];
-        this.alertCallbacks = [];
-    }
-}
-
-class SecurityLogger {
-    constructor(config) {
-        this.eventQueue = [];
-        this.config = {
-            enableLocalLogging: true,
-            batchSize: 10,
-            flushInterval: 5000,
-            sessionId: '',
-            organizationId: '',
-            ...config
-        };
-        if (this.config.flushInterval > 0) {
-            this.startAutoFlush();
-        }
-    }
-    setSessionId(sessionId) {
-        this.config.sessionId = sessionId;
-    }
-    logEvent(eventType, severity, details) {
-        const event = {
-            eventType,
-            severity,
-            details: {
-                ...details,
-                sessionId: this.config.sessionId,
-                organizationId: this.config.organizationId,
-                userAgent: typeof navigator !== 'undefined' ? navigator.userAgent : undefined,
-                timestamp: new Date().toISOString()
-            },
-            timestamp: new Date()
-        };
-        if (this.config.enableLocalLogging) {
-            this.logToConsole(event);
-        }
-        this.eventQueue.push(event);
-        if (this.eventQueue.length >= this.config.batchSize) {
-            this.flush().catch(() => { });
-        }
-    }
-    logAuthFailure(reason, details) {
-        this.logEvent('auth_failure', 'warning', {
-            reason,
-            ...details
-        });
-    }
-    logRateLimit(limit, current, endpoint) {
-        this.logEvent('rate_limit', 'warning', {
-            limit,
-            current,
-            endpoint,
-            exceeded: current >= limit
-        });
-    }
-    logInvalidRequest(reason, request) {
-        this.logEvent('invalid_request', 'warning', {
-            reason,
-            request: this.sanitizeRequest(request)
-        });
-    }
-    logSessionHijackAttempt(details) {
-        this.logEvent('session_hijack', 'critical', details);
-    }
-    sanitizeRequest(request) {
-        if (!request)
-            return undefined;
-        const sanitized = { ...request };
-        const sensitiveFields = ['password', 'token', 'apiKey', 'secret', 'credential'];
-        for (const field of sensitiveFields) {
-            if (sanitized[field]) {
-                sanitized[field] = '[REDACTED]';
-            }
-        }
-        return sanitized;
-    }
-    logToConsole(event) {
-    }
-    getConsoleLogLevel(severity) {
-        switch (severity) {
-            case 'info':
-                return 'log';
-            case 'warning':
-                return 'warn';
-            case 'error':
-            case 'critical':
-                return 'error';
-            default:
-                return 'log';
-        }
-    }
-    async flush() {
-        if (this.eventQueue.length === 0)
-            return;
-        const events = [...this.eventQueue];
-        this.eventQueue = [];
-        try {
-            const response = await fetch(`${this.config.apiEndpoint}/security/events`, {
-                method: 'POST',
-                headers: {
-                    'Authorization': `Bearer ${this.config.apiKey}`,
-                    'Content-Type': 'application/json'
-                },
-                body: JSON.stringify({ events })
-            });
-            if (!response.ok) {
-                this.eventQueue.unshift(...events);
-            }
-        }
-        catch (error) {
-            this.eventQueue.unshift(...events);
-        }
-    }
-    startAutoFlush() {
-        this.flushInterval = setInterval(() => {
-            this.flush().catch(() => { });
-        }, this.config.flushInterval);
-    }
-    stopAutoFlush() {
-        if (this.flushInterval) {
-            clearInterval(this.flushInterval);
-            this.flushInterval = undefined;
-        }
-    }
-    async destroy() {
-        this.stopAutoFlush();
-        await this.flush();
-    }
-}
-
-class ConnectionStateManager extends eventemitter3.EventEmitter {
-    constructor() {
-        super();
-        this.stateHistory = [];
-        this.maxHistorySize = 100;
-        this.state = {
-            signaling: 'disconnected',
-            websocket: 'new',
-            overall: 'disconnected',
-            lastActivity: new Date(),
-            reconnectAttempts: 0,
-            errors: []
-        };
-        this.quality = {
-            qualityScore: 1.0
-        };
-    }
-    updateSignalingState(state) {
-        const previousState = this.state.signaling;
-        this.state.signaling = state;
-        this.state.lastActivity = new Date();
-        if (state === 'connected') {
-            this.state.reconnectAttempts = 0;
-        }
-        else if (state === 'reconnecting') {
-            this.state.reconnectAttempts++;
-        }
-        this.updateOverallState();
-        this.addToHistory();
-        if (previousState !== state) {
-            this.emit('signalingStateChange', state, previousState);
-        }
-    }
-    updateWebSocketState(state) {
-        const previousState = this.state.websocket;
-        this.state.websocket = state;
-        this.state.lastActivity = new Date();
-        this.updateOverallState();
-        this.addToHistory();
-        if (previousState !== state) {
-            this.emit('websocketStateChange', state, previousState);
-        }
-    }
-    updateWebRTCState(state) {
-        this.updateWebSocketState(state);
-    }
-    updateICEState(state) {
-        // No-op for backwards compatibility
-    }
-    updateOverallState() {
-        const previousOverall = this.state.overall;
-        if (this.state.signaling === 'disconnected' || this.state.websocket === 'failed' || this.state.websocket === 'closed') {
-            this.state.overall = 'disconnected';
-        }
-        else if (this.state.signaling === 'connecting' || this.state.websocket === 'connecting') {
-            this.state.overall = 'connecting';
-        }
-        else if (this.state.signaling === 'connected' && this.state.websocket === 'connected') {
-            this.state.overall = 'connected';
-        }
-        else if (this.state.signaling === 'reconnecting' || this.state.websocket === 'disconnected') {
-            this.state.overall = 'degraded';
-        }
-        else if (this.state.errors.length > 0) {
-            this.state.overall = 'error';
-        }
-        else {
-            this.state.overall = 'connecting';
-        }
-        if (previousOverall !== this.state.overall) {
-            this.emit('overallStateChange', this.state.overall, previousOverall);
-        }
-    }
-    addError(error) {
-        this.state.errors.push(error);
-        if (this.state.errors.length > 10) {
-            this.state.errors = this.state.errors.slice(-10);
-        }
-        this.updateOverallState();
-        this.emit('error', error);
-    }
-    clearErrors() {
-        this.state.errors = [];
-        this.updateOverallState();
-    }
-    updateConnectionQuality(stats) {
-        const previousScore = this.quality.qualityScore;
-        if (stats.latency !== undefined)
-            this.quality.latency = stats.latency;
-        if (stats.jitter !== undefined)
-            this.quality.jitter = stats.jitter;
-        if (stats.packetLoss !== undefined)
-            this.quality.packetLoss = stats.packetLoss;
-        if (stats.bandwidth !== undefined)
-            this.quality.bandwidth = stats.bandwidth;
-        this.quality.qualityScore = this.calculateQualityScore();
-        if (Math.abs(previousScore - this.quality.qualityScore) > 0.1) {
-            this.emit('qualityChange', this.quality);
-        }
-    }
-    calculateQualityScore() {
-        let score = 1.0;
-        if (this.quality.latency !== undefined) {
-            if (this.quality.latency < 150) ;
-            else if (this.quality.latency < 300) {
-                score -= 0.1;
-            }
-            else if (this.quality.latency < 500) {
-                score -= 0.3;
-            }
-            else {
-                score -= 0.5;
-            }
-        }
-        if (this.quality.packetLoss !== undefined) {
-            if (this.quality.packetLoss < 1) ;
-            else if (this.quality.packetLoss < 3) {
-                score -= 0.2;
-            }
-            else if (this.quality.packetLoss < 5) {
-                score -= 0.4;
-            }
-            else {
-                score -= 0.6;
-            }
-        }
-        if (this.quality.jitter !== undefined) {
-            if (this.quality.jitter < 30) ;
-            else if (this.quality.jitter < 50) {
-                score -= 0.1;
-            }
-            else if (this.quality.jitter < 100) {
-                score -= 0.2;
-            }
-            else {
-                score -= 0.3;
-            }
-        }
-        return Math.max(0, Math.min(1, score));
-    }
-    startHealthCheck(intervalMs = 5000) {
-        this.stopHealthCheck();
-        this.healthCheckInterval = setInterval(() => {
-            const timeSinceLastActivity = Date.now() - this.state.lastActivity.getTime();
-            if (timeSinceLastActivity > 30000 && this.state.overall === 'connected') {
-                this.emit('healthCheckFailed', timeSinceLastActivity);
-            }
-        }, intervalMs);
-    }
-    stopHealthCheck() {
-        if (this.healthCheckInterval) {
-            clearInterval(this.healthCheckInterval);
-            this.healthCheckInterval = undefined;
-        }
-    }
-    addToHistory() {
-        this.stateHistory.push({
-            state: { ...this.state },
-            timestamp: new Date()
-        });
-        if (this.stateHistory.length > this.maxHistorySize) {
-            this.stateHistory = this.stateHistory.slice(-this.maxHistorySize);
-        }
-    }
-    getState() {
-        return { ...this.state };
-    }
-    getQuality() {
-        return { ...this.quality };
-    }
-    getStateHistory() {
-        return [...this.stateHistory];
-    }
-    isConnected() {
-        return this.state.overall === 'connected';
-    }
-    isHealthy() {
-        return this.state.overall === 'connected' &&
-            this.quality.qualityScore > 0.5 &&
-            this.state.errors.length === 0;
-    }
-    getReconnectAttempts() {
-        return this.state.reconnectAttempts;
-    }
-    reset() {
-        this.state = {
-            signaling: 'disconnected',
-            websocket: 'new',
-            overall: 'disconnected',
-            lastActivity: new Date(),
-            reconnectAttempts: 0,
-            errors: []
-        };
-        this.quality = {
-            qualityScore: 1.0
-        };
-        this.stateHistory = [];
-        this.emit('reset');
-    }
-    destroy() {
-        this.stopHealthCheck();
-        this.removeAllListeners();
-    }
-}
-
-class PerformanceMonitor extends eventemitter3.EventEmitter {
-    constructor(config) {
-        super();
-        this.benchmarks = [];
-        this.isCollecting = false;
-        this.config = {
-            collectionInterval: 5000,
-            enableAutoReport: true,
-            reportingInterval: 30000,
-            sessionId: '',
-            ...config
-        };
-        this.startTime = Date.now();
-        this.metrics = this.initializeMetrics();
-    }
-    initializeMetrics() {
-        return {
-            latency: {
-                signaling: { avg: 0, min: Infinity, max: 0, samples: [] },
-                websocket: { avg: 0, min: Infinity, max: 0, samples: [] },
-                audio: { avg: 0, min: Infinity, max: 0, samples: [] }
-            },
-            throughput: {
-                audio: { inbound: 0, outbound: 0 },
-                data: { inbound: 0, outbound: 0 }
-            },
-            quality: {
-                audioQuality: 1.0,
-                connectionQuality: 1.0
-            },
-            resources: {
-                cpuUsage: 0,
-                memoryUsage: 0,
-                bandwidth: { upload: 0, download: 0 }
-            }
-        };
-    }
-    startCollection(sessionId) {
-        if (this.isCollecting)
-            return;
-        this.isCollecting = true;
-        if (sessionId) {
-            this.config.sessionId = sessionId;
-        }
-        this.collectionTimer = setInterval(() => {
-            this.collectMetrics();
-        }, this.config.collectionInterval);
-        if (this.config.enableAutoReport) {
-            this.reportingTimer = setInterval(() => {
-                this.reportMetrics();
-            }, this.config.reportingInterval);
-        }
-        this.emit('collectionStarted');
-    }
-    stopCollection() {
-        if (!this.isCollecting)
-            return;
-        this.isCollecting = false;
-        if (this.collectionTimer) {
-            clearInterval(this.collectionTimer);
-            this.collectionTimer = undefined;
-        }
-        if (this.reportingTimer) {
-            clearInterval(this.reportingTimer);
-            this.reportingTimer = undefined;
-        }
-        if (this.config.enableAutoReport) {
-            this.reportMetrics();
-        }
-        this.emit('collectionStopped');
-    }
-    recordLatency(type, latency) {
-        const key = type === 'webrtc' ? 'websocket' : type === 'video' ? 'audio' : type;
-        const metric = this.metrics.latency[key];
-        if (!metric)
-            return;
-        metric.samples.push(latency);
-        if (metric.samples.length > 100) {
-            metric.samples.shift();
-        }
-        metric.min = Math.min(metric.min, latency);
-        metric.max = Math.max(metric.max, latency);
-        metric.avg = metric.samples.reduce((a, b) => a + b, 0) / metric.samples.length;
-    }
-    updateThroughput(type, direction, bytesPerSecond) {
-        const key = type === 'video' ? 'audio' : type;
-        if (this.metrics.throughput[key]) {
-            this.metrics.throughput[key][direction] = bytesPerSecond;
-        }
-    }
-    updateQuality(quality) {
-        this.metrics.quality = { ...this.metrics.quality, ...quality };
-    }
-    updateResources(resources) {
-        this.metrics.resources = { ...this.metrics.resources, ...resources };
-    }
-    recordBenchmark(benchmark) {
-        const fullBenchmark = {
-            ...benchmark,
-            timestamp: new Date()
-        };
-        this.benchmarks.push(fullBenchmark);
-        if (this.benchmarks.length > 50) {
-            this.benchmarks.shift();
-        }
-        this.emit('benchmarkRecorded', fullBenchmark);
-    }
-    getMetrics() {
-        return JSON.parse(JSON.stringify(this.metrics));
-    }
-    getBenchmarks() {
-        return [...this.benchmarks];
-    }
-    getLatencyStats(type) {
-        if (type) {
-            const key = type === 'webrtc' ? 'websocket' : type === 'video' ? 'audio' : type;
-            return { ...this.metrics.latency[key] };
-        }
-        return JSON.parse(JSON.stringify(this.metrics.latency));
-    }
-    async reportMetrics() {
-        if (!this.config.sessionId)
-            return;
-        try {
-            const report = {
-                sessionId: this.config.sessionId,
-                timestamp: new Date(),
-                duration: Date.now() - this.startTime,
-                metrics: this.getMetrics(),
-                benchmarks: this.getBenchmarks()
-            };
-            const response = await fetch(`${this.config.apiEndpoint}/performance/report`, {
-                method: 'POST',
-                headers: {
-                    'Content-Type': 'application/json'
-                },
-                body: JSON.stringify(report)
-            });
-            if (!response.ok) {
-                throw new Error(`Failed to report metrics: ${response.statusText}`);
-            }
-            this.emit('metricsReported', report);
-        }
-        catch (error) {
-            this.emit('error', error);
-        }
-    }
-    collectMetrics() {
-        this.emit('collectMetrics', {
-            timestamp: Date.now(),
-            metrics: this.metrics
-        });
-    }
-    destroy() {
-        this.stopCollection();
-        this.removeAllListeners();
-        this.benchmarks = [];
-    }
-}
-
-class AnalyticsCollector extends eventemitter3.EventEmitter {
-    constructor(config) {
-        super();
-        this.events = [];
-        this.sessionAnalytics = null;
-        this.isCollecting = false;
-        this.config = {
-            enableAutoFlush: true,
-            flushInterval: 60000, // 1 minute
-            batchSize: 100,
-            sessionId: '',
-            userId: '',
-            organizationId: '',
-            ...config
-        };
-    }
-    startSession(sessionId) {
-        if (this.isCollecting) {
-            this.endSession();
-        }
-        this.isCollecting = true;
-        this.config.sessionId = sessionId;
-        this.sessionAnalytics = {
-            sessionId,
-            startTime: new Date(),
-            duration: 0,
-            eventsCount: 0,
-            errorCount: 0,
-            mediaTypes: [],
-            connectionQuality: 1.0,
-            dataTransferred: {
-                audio: { sent: 0, received: 0 },
-                video: { sent: 0, received: 0 },
-                text: { sent: 0, received: 0 }
-            }
-        };
-        if (this.config.enableAutoFlush) {
-            this.flushTimer = setInterval(() => {
-                this.flush();
-            }, this.config.flushInterval);
-        }
-        this.trackEvent('session_started', {});
-    }
-    endSession() {
-        if (!this.isCollecting || !this.sessionAnalytics)
-            return;
-        this.isCollecting = false;
-        this.sessionAnalytics.endTime = new Date();
-        this.sessionAnalytics.duration =
-            (this.sessionAnalytics.endTime.getTime() - this.sessionAnalytics.startTime.getTime()) / 1000;
-        this.trackEvent('session_ended', {
-            duration: this.sessionAnalytics.duration
-        });
-        this.flush();
-        if (this.flushTimer) {
-            clearInterval(this.flushTimer);
-            this.flushTimer = undefined;
-        }
-        this.sendSessionAnalytics();
-    }
-    trackEvent(eventType, metadata = {}) {
-        const event = {
-            eventType,
-            timestamp: new Date(),
-            sessionId: this.config.sessionId,
-            userId: this.config.userId,
-            organizationId: this.config.organizationId,
-            metadata
-        };
-        this.events.push(event);
-        if (this.sessionAnalytics) {
-            this.sessionAnalytics.eventsCount++;
-            if (eventType.includes('error') || metadata.error) {
-                this.sessionAnalytics.errorCount++;
-            }
-        }
-        if (this.events.length >= this.config.batchSize) {
-            this.flush();
-        }
-        this.emit('eventTracked', event);
-    }
-    updateMediaTypes(mediaTypes) {
-        if (this.sessionAnalytics) {
-            this.sessionAnalytics.mediaTypes = [...new Set(mediaTypes)];
-        }
-    }
-    updateConnectionQuality(quality) {
-        if (this.sessionAnalytics) {
-            const weight = 0.1;
-            this.sessionAnalytics.connectionQuality =
-                this.sessionAnalytics.connectionQuality * (1 - weight) + quality * weight;
-        }
-    }
-    updateDataTransferred(type, direction, bytes) {
-        if (this.sessionAnalytics) {
-            this.sessionAnalytics.dataTransferred[type][direction] += bytes;
-        }
-    }
-    getSessionAnalytics() {
-        if (!this.sessionAnalytics)
-            return null;
-        return {
-            ...this.sessionAnalytics,
-            duration: this.isCollecting
-                ? (Date.now() - this.sessionAnalytics.startTime.getTime()) / 1000
-                : this.sessionAnalytics.duration
-        };
-    }
-    getEvents() {
-        return [...this.events];
-    }
-    async flush() {
-        if (this.events.length === 0)
-            return;
-        const eventsToSend = [...this.events];
-        this.events = [];
-        try {
-            const response = await fetch(`${this.config.apiEndpoint}/analytics/events`, {
-                method: 'POST',
-                headers: {
-                    'Content-Type': 'application/json',
-                    'Authorization': `Bearer ${this.config.apiKey}`
-                },
-                body: JSON.stringify({
-                    events: eventsToSend
-                })
-            });
-            if (!response.ok) {
-                throw new Error(`Failed to send analytics: ${response.statusText}`);
-            }
-            this.emit('eventsFlushed', eventsToSend.length);
-        }
-        catch (error) {
-            this.events.unshift(...eventsToSend);
-            this.emit('error', error);
-        }
-    }
-    async sendSessionAnalytics() {
-        if (!this.sessionAnalytics)
-            return;
-        try {
-            const response = await fetch(`${this.config.apiEndpoint}/analytics/sessions`, {
-                method: 'POST',
-                headers: {
-                    'Content-Type': 'application/json',
-                    'Authorization': `Bearer ${this.config.apiKey}`
-                },
-                body: JSON.stringify(this.sessionAnalytics)
-            });
-            if (!response.ok) {
-                throw new Error(`Failed to send session analytics: ${response.statusText}`);
-            }
-            this.emit('sessionAnalyticsSent', this.sessionAnalytics);
-        }
-        catch (error) {
-            this.emit('error', error);
-        }
-    }
-    destroy() {
-        if (this.isCollecting) {
-            this.endSession();
-        }
-        if (this.flushTimer) {
-            clearInterval(this.flushTimer);
-            this.flushTimer = undefined;
-        }
-        this.removeAllListeners();
-        this.events = [];
-        this.sessionAnalytics = null;
-    }
-}
-
-class UsageTracker {
-    constructor(sessionId) {
-        this.inputTokens = 0;
-        this.outputTokens = 0;
-        this.errorCount = 0;
-        this.qualityScores = [];
-        this.sessionId = sessionId;
-        this.startTime = new Date();
-    }
-    start() {
-        this.startTime = new Date();
-    }
-    stop() {
-        this.endTime = new Date();
-    }
-    trackInputTokens(tokens) {
-        this.inputTokens += tokens;
-    }
-    trackOutputTokens(tokens) {
-        this.outputTokens += tokens;
-    }
-    trackError() {
-        this.errorCount++;
-    }
-    trackQualityScore(score) {
-        if (score >= 0 && score <= 1) {
-            this.qualityScores.push(score);
-        }
-    }
-    getDuration() {
-        const end = this.endTime || new Date();
-        return Math.floor((end.getTime() - this.startTime.getTime()) / 1000);
-    }
-    getAverageQualityScore() {
-        if (this.qualityScores.length === 0)
-            return undefined;
-        const sum = this.qualityScores.reduce((acc, score) => acc + score, 0);
-        return sum / this.qualityScores.length;
-    }
-    getMetrics() {
-        return {
-            sessionId: this.sessionId,
-            duration: this.getDuration(),
-            inputTokens: this.inputTokens > 0 ? this.inputTokens : undefined,
-            outputTokens: this.outputTokens > 0 ? this.outputTokens : undefined,
-            errorCount: this.errorCount,
-            qualityScore: this.getAverageQualityScore()
-        };
-    }
-    reset() {
-        this.startTime = new Date();
-        this.endTime = undefined;
-        this.inputTokens = 0;
-        this.outputTokens = 0;
-        this.errorCount = 0;
-        this.qualityScores = [];
-    }
-}
-
-/**
- * @deprecated This module is deprecated. Use AStackCSRClient for WebSocket-based communication.
- * This file is kept for backwards compatibility only.
- */
-/**
- * @deprecated Use AStackCSRClient instead. This function is kept for backwards compatibility.
- */
-function setupEventHandlers(emitter, deps) {
-    console.warn('setupEventHandlers is deprecated. Use AStackCSRClient for WebSocket-based communication.');
-    const { signaling, connectionStateManager, securityLogger } = deps;
-    signaling.on('sessionJoined', () => {
-        const sessionId = deps.getSessionId();
-        const usageTracker = new UsageTracker(sessionId);
-        usageTracker.start();
-        deps.setUsageTracker(usageTracker);
-        securityLogger.setSessionId(sessionId);
-        connectionStateManager.updateSignalingState('connected');
-        connectionStateManager.startHealthCheck();
-        emitter.emit('sessionReady', sessionId);
-    });
-    signaling.on('aiResponse', (data) => {
-        const response = {
-            type: 'text',
-            content: data.text || data.message,
-            timestamp: data.timestamp || Date.now(),
-            messageId: data.messageId
-        };
-        emitter.emit('messageReceived', response);
-    });
-    signaling.on('audioResponse', (data) => {
-        if (data.audio) {
-            try {
-                const binaryString = atob(data.audio.split(',')[1]);
-                const bytes = new Uint8Array(binaryString.length);
-                for (let i = 0; i < binaryString.length; i++) {
-                    bytes[i] = binaryString.charCodeAt(i);
-                }
-                const audioBlob = new Blob([bytes], { type: 'audio/wav' });
-                const response = {
-                    type: 'audio',
-                    content: audioBlob,
-                    timestamp: data.timestamp || Date.now(),
-                    messageId: data.messageId
-                };
-                emitter.emit('messageReceived', response);
-            }
-            catch (error) { }
-        }
-    });
-    signaling.on('textResponse', (data) => {
-        emitter.emit('text-response', data);
-    });
-    signaling.on('disconnected', () => {
-        deps.setStatus({ status: 'disconnected' });
-        connectionStateManager.updateSignalingState('disconnected');
-        emitter.emit('disconnected');
-    });
-    signaling.on('reconnecting', (attempt) => {
-        connectionStateManager.updateSignalingState('reconnecting');
-        emitter.emit('reconnecting', attempt);
-    });
-    signaling.on('error', (error) => {
-        const usageTracker = deps.getUsageTracker();
-        if (usageTracker) {
-            usageTracker.trackError();
-        }
-        connectionStateManager.addError(error);
-        if (error.code === ErrorCodes.AUTHENTICATION_FAILED || error.code === ErrorCodes.INVALID_API_KEY) {
-            securityLogger.logAuthFailure(error.message, { code: error.code });
-        }
-        else if (error.code === ErrorCodes.RATE_LIMIT_EXCEEDED) {
-            securityLogger.logRateLimit(0, 0, 'signaling');
-        }
-        emitter.emit('error', error);
-    });
-}
-
-class AStackMediaController {
-    constructor(webrtc, signaling, analyticsCollector, config, emitter) {
-        this.audioRecorder = null;
-        this.isRecording = false;
-        this.webrtc = webrtc;
-        this.signaling = signaling;
-        this.analyticsCollector = analyticsCollector;
-        this.config = config;
-        this.emitter = emitter;
-    }
-    async startVideo() {
-        if (!this.config.enableVideo) {
-            throw new AStackError('Video is disabled in configuration', ErrorCodes.VIDEO_ERROR);
-        }
-        try {
-            const stream = await this.webrtc.getUserMedia();
-            this.webrtc.addLocalStream(stream);
-            this.emitter.emit('videoStarted');
-            this.analyticsCollector.trackEvent('video_started');
-            this.analyticsCollector.updateMediaTypes(['video']);
-            return stream;
-        }
-        catch (error) {
-            throw new AStackError(`Failed to start video: ${error}`, ErrorCodes.VIDEO_ERROR);
-        }
-    }
-    async stopVideo(localVideoRef) {
-        const localStreams = this.webrtc.getLocalStreams();
-        localStreams.forEach(stream => {
-            if (stream.kind === 'video') {
-                this.webrtc.removeLocalStream(stream.id);
-            }
-        });
-        if (localVideoRef) {
-            localVideoRef.srcObject = null;
-        }
-        this.emitter.emit('videoStopped');
-    }
-    async startAudio() {
-        if (this.config.enableAudio === false) {
-            throw new AStackError('Audio is disabled in configuration', ErrorCodes.AUDIO_ERROR);
-        }
-        try {
-            const stream = await this.webrtc.getUserMedia();
-            this.webrtc.addLocalStream(stream);
-            this.emitter.emit('audioStarted');
-            this.analyticsCollector.trackEvent('audio_started');
-            this.analyticsCollector.updateMediaTypes(['audio']);
-            return stream;
-        }
-        catch (error) {
-            throw new AStackError(`Failed to start audio: ${error}`, ErrorCodes.AUDIO_ERROR);
-        }
-    }
-    async stopAudio() {
-        const localStreams = this.webrtc.getLocalStreams();
-        localStreams.forEach(stream => {
-            if (stream.kind === 'audio') {
-                this.webrtc.removeLocalStream(stream.id);
-            }
-        });
-        if (this.isRecording) {
-            this.stopRecording();
-        }
-        this.emitter.emit('audioStopped');
-    }
-    async sendText(message) {
-        if (!this.signaling.isConnected()) {
-            throw new AStackError('Not connected to AStack', ErrorCodes.CONNECTION_LOST);
-        }
-        try {
-            this.signaling.sendTextMessage(message);
-            this.emitter.emit('messageSent', message);
-        }
-        catch (error) {
-            throw new AStackError(`Failed to send text message: ${error}`, ErrorCodes.SIGNALING_ERROR);
-        }
-    }
-    async sendAudio(audioBlob) {
-        if (!this.signaling.isConnected()) {
-            throw new AStackError('Not connected to AStack', ErrorCodes.CONNECTION_LOST);
-        }
-        try {
-            this.signaling.sendAudioData(audioBlob);
-            this.emitter.emit('messageSent', audioBlob);
-        }
-        catch (error) {
-            throw new AStackError(`Failed to send audio: ${error}`, ErrorCodes.AUDIO_ERROR);
-        }
-    }
-    startRecording() {
-        const localStreams = this.webrtc.getLocalStreams();
-        const audioStream = localStreams.find(s => s.kind === 'audio');
-        if (!audioStream?.track) {
-            throw new AStackError('No audio stream available for recording', ErrorCodes.AUDIO_ERROR);
-        }
-        const stream = new MediaStream([audioStream.track]);
-        this.audioRecorder = new MediaRecorder(stream, { mimeType: 'audio/webm' });
-        const audioChunks = [];
-        this.audioRecorder.ondataavailable = (event) => {
-            if (event.data.size > 0) {
-                audioChunks.push(event.data);
-            }
-        };
-        this.audioRecorder.onstop = () => {
-            const audioBlob = new Blob(audioChunks, { type: 'audio/webm' });
-            this.sendAudio(audioBlob);
-        };
-        this.audioRecorder.start();
-        this.isRecording = true;
-    }
-    stopRecording() {
-        if (this.audioRecorder && this.isRecording) {
-            this.audioRecorder.stop();
-            this.isRecording = false;
-        }
-    }
-    getIsRecording() {
-        return this.isRecording;
-    }
-    async getDevices() {
-        return this.webrtc.getMediaDevices();
-    }
-    async switchCamera(deviceId) {
-        throw new AStackError('Camera switching not yet implemented', ErrorCodes.VIDEO_ERROR);
-    }
-    async switchMicrophone(deviceId) {
-        return this.webrtc.switchAudioInput(deviceId);
-    }
-    muteAudio() {
-        this.webrtc.muteAudio();
-    }
-    unmuteAudio() {
-        this.webrtc.unmuteAudio();
-    }
-    pauseVideo() {
-        this.webrtc.muteVideo();
-    }
-    resumeVideo() {
-        this.webrtc.unmuteVideo();
-    }
-    getLocalStreams() {
-        return this.webrtc.getLocalStreams();
-    }
-    getRemoteStreams() {
-        return this.webrtc.getRemoteStreams();
-    }
-}
-
-/**
- * @deprecated AStackClient is deprecated. Use AStackCSRClient for WebSocket-based communication.
- * This class is kept for backwards compatibility only.
- *
- * Example:
- * ```typescript
- * import { AStackCSRClient } from '@astack/client-sdk';
- * const client = new AStackCSRClient({ apiEndpoint: 'https://api.astack.com' });
- * ```
- */
-class AStackClient extends eventemitter3.EventEmitter {
-    constructor(config) {
-        super();
-        this.usageTracker = null;
-        this.sessionId = null;
-        this.localVideoRef = null;
-        this.remoteVideoRef = null;
-        if (!config.apiKey) {
-            throw new AStackError('API key is required', ErrorCodes.INVALID_API_KEY);
-        }
-        if (!config.supabaseUrl || !config.supabaseAnonKey) {
-            throw new AStackError('Supabase URL and Anon Key are required', ErrorCodes.AUTHENTICATION_FAILED);
-        }
-        this.config = {
-            enableVideo: false, enableAudio: true, enableText: true, autoReconnect: true,
-            maxRetries: 3, reconnectDelay: 1000, heartbeatInterval: 30000, connectionTimeout: 10000,
-            sessionExpirationWarning: 1, apiEndpoint: `${config.supabaseUrl}/functions/v1`, ...config
-        };
-        this.webrtc = new WebRTCManager(this.config);
-        this.signaling = new SupabaseSignalingClient(this.config);
-        this.sessionManager = new SessionManager(this.config.apiEndpoint, this.config.sessionExpirationWarning, (minutesRemaining) => this.emit('sessionExpiring', minutesRemaining));
-        this.billingMonitor = new BillingMonitor(this.config.apiEndpoint, this.config.apiKey);
-        this.billingMonitor.onAlert((alert) => this.emit('billingAlert', alert));
-        this.securityLogger = new SecurityLogger({
-            apiEndpoint: this.config.apiEndpoint, apiKey: this.config.apiKey,
-            organizationId: this.config.organizationId, enableLocalLogging: true
-        });
-        this.connectionStateManager = new ConnectionStateManager();
-        this.connectionStateManager.on('qualityChange', (quality) => {
-            this.analyticsCollector.updateConnectionQuality(quality.qualityScore);
-        });
-        this.performanceMonitor = new PerformanceMonitor({
-            apiEndpoint: this.config.apiEndpoint,
-            enableAutoReport: this.config.enablePerformanceReporting ?? true,
-            collectionInterval: this.config.performanceCollectionInterval ?? 5000,
-            reportingInterval: this.config.performanceReportingInterval ?? 30000
-        });
-        this.analyticsCollector = new AnalyticsCollector({
-            apiEndpoint: this.config.apiEndpoint, apiKey: this.config.apiKey,
-            organizationId: this.config.organizationId, userId: this.config.endUserId,
-            enableAutoFlush: this.config.enableAnalytics ?? true
-        });
-        this.mediaController = new AStackMediaController(this.webrtc, this.signaling, this.analyticsCollector, this.config, this);
-        this.status = { id: '', status: 'pending', connectionState: 'disconnected', iceConnectionState: 'new' };
-        this.initEventHandlers();
-    }
-    initEventHandlers() {
-        setupEventHandlers(this, {
-            webrtc: this.webrtc, signaling: this.signaling,
-            connectionStateManager: this.connectionStateManager, analyticsCollector: this.analyticsCollector,
-            securityLogger: this.securityLogger, performanceMonitor: this.performanceMonitor,
-            getUsageTracker: () => this.usageTracker, setUsageTracker: (t) => { this.usageTracker = t; },
-            getSessionId: () => this.sessionId, getStatus: () => this.status,
-            setStatus: (s) => { this.status = { ...this.status, ...s }; },
-            localVideoRef: this.localVideoRef, remoteVideoRef: this.remoteVideoRef,
-            startWebRTCStatsCollection: () => this.startWebRTCStatsCollection(),
-            stopWebRTCStatsCollection: () => this.stopWebRTCStatsCollection()
-        });
-    }
-    startWebRTCStatsCollection() {
-        this.stopWebRTCStatsCollection();
-        this.statsCollectionTimer = setInterval(async () => {
-            try {
-                const stats = await this.webrtc.getStats();
-                if (stats) {
-                    const processed = this.processWebRTCStats(stats);
-                    if (processed.audioLatency !== undefined)
-                        this.performanceMonitor.recordLatency('audio', processed.audioLatency);
-                    if (processed.videoLatency !== undefined)
-                        this.performanceMonitor.recordLatency('video', processed.videoLatency);
-                    if (processed.throughput) {
-                        this.performanceMonitor.updateThroughput('audio', 'inbound', processed.throughput.audio.inbound);
-                        this.performanceMonitor.updateThroughput('audio', 'outbound', processed.throughput.audio.outbound);
-                        this.performanceMonitor.updateThroughput('video', 'inbound', processed.throughput.video.inbound);
-                        this.performanceMonitor.updateThroughput('video', 'outbound', processed.throughput.video.outbound);
-                    }
-                    if (processed.quality)
-                        this.performanceMonitor.updateQuality(processed.quality);
-                }
-            }
-            catch (error) { }
-        }, 5000);
-    }
-    stopWebRTCStatsCollection() {
-        if (this.statsCollectionTimer) {
-            clearInterval(this.statsCollectionTimer);
-            this.statsCollectionTimer = undefined;
-        }
-    }
-    processWebRTCStats(stats) {
-        return { throughput: { audio: { inbound: 0, outbound: 0 }, video: { inbound: 0, outbound: 0 } }, quality: {} };
-    }
-    async connect() {
-        try {
-            this.connectionStateManager.updateSignalingState('connecting');
-            const sessionRequest = {
-                apiKey: this.config.apiKey, organizationId: this.config.organizationId,
-                endUserId: this.config.endUserId,
-                metadata: { enableVideo: this.config.enableVideo, enableAudio: this.config.enableAudio },
-                workerPreferences: this.config.workerPreferences
-            };
-            const credentials = await this.sessionManager.createSession(sessionRequest);
-            this.sessionId = credentials.sessionId;
-            this.status = {
-                id: this.sessionId, status: 'connecting', connectionState: 'disconnected',
-                iceConnectionState: 'new', startTime: new Date()
-            };
-            this.billingMonitor.startMonitoring();
-            this.performanceMonitor.startCollection(this.sessionId);
-            this.analyticsCollector.startSession(this.sessionId);
-            await this.webrtc.initialize();
-            await this.signaling.connect(credentials.sessionId, credentials.channelName, credentials.wsToken);
-        }
-        catch (error) {
-            this.status.status = 'error';
-            this.status.lastError = error;
-            if (error instanceof AStackError) {
-                if (error.code === ErrorCodes.INSUFFICIENT_CREDITS) {
-                    this.emit('billingAlert', { type: 'limit_exceeded', details: { error: error.message } });
-                }
-                else if (error.code === ErrorCodes.RATE_LIMIT_EXCEEDED) {
-                    this.emit('rateLimitWarning', { limit: 0, current: 0, resetIn: 60 });
-                }
-            }
-            throw error;
-        }
-    }
-    async startVideo() { return this.mediaController.startVideo(); }
-    async stopVideo() { return this.mediaController.stopVideo(this.localVideoRef); }
-    async startAudio() { return this.mediaController.startAudio(); }
-    async stopAudio() { return this.mediaController.stopAudio(); }
-    async sendText(message) { return this.mediaController.sendText(message); }
-    async sendAudio(audioBlob) { return this.mediaController.sendAudio(audioBlob); }
-    startRecording() { this.mediaController.startRecording(); }
-    stopRecording() { this.mediaController.stopRecording(); }
-    async getDevices() { return this.mediaController.getDevices(); }
-    async switchCamera(deviceId) { return this.mediaController.switchCamera(deviceId); }
-    async switchMicrophone(deviceId) { return this.mediaController.switchMicrophone(deviceId); }
-    muteAudio() { this.mediaController.muteAudio(); }
-    unmuteAudio() { this.mediaController.unmuteAudio(); }
-    pauseVideo() { this.mediaController.pauseVideo(); }
-    resumeVideo() { this.mediaController.resumeVideo(); }
-    getSessionStatus() { return { ...this.status }; }
-    getLocalStreams() { return this.mediaController.getLocalStreams(); }
-    getRemoteStreams() { return this.mediaController.getRemoteStreams(); }
-    attachVideo(localVideo, remoteVideo) {
-        this.localVideoRef = localVideo;
-        this.remoteVideoRef = remoteVideo;
-    }
-    addEventListener(event, listener) {
-        return super.on(event, listener);
-    }
-    removeEventListener(event, listener) {
-        return super.off(event, listener);
-    }
-    async disconnect() {
-        this.status.status = 'disconnected';
-        if (this.mediaController.getIsRecording())
-            this.mediaController.stopRecording();
-        if (this.usageTracker) {
-            this.usageTracker.stop();
-            this.usageTracker.getMetrics();
-        }
-        this.billingMonitor.stopMonitoring();
-        this.performanceMonitor.stopCollection();
-        this.analyticsCollector.endSession();
-        this.connectionStateManager.stopHealthCheck();
-        this.connectionStateManager.updateSignalingState('disconnected');
-        await this.webrtc.close();
-        await this.signaling.disconnect();
-        this.sessionManager.clearSession();
-        if (this.localVideoRef)
-            this.localVideoRef.srcObject = null;
-        if (this.remoteVideoRef)
-            this.remoteVideoRef.srcObject = null;
-        this.emit('sessionEnded', this.sessionId);
-        this.sessionId = null;
-        this.usageTracker = null;
-    }
-    async renewSession() {
-        if (!this.sessionManager.isSessionValid()) {
-            throw new AStackError('No active session to renew', ErrorCodes.SESSION_EXPIRED);
-        }
-        try {
-            const credentials = await this.sessionManager.renewSession(this.config.apiKey);
-            await this.signaling.disconnect();
-            await this.signaling.connect(credentials.sessionId, credentials.channelName, credentials.wsToken);
-            this.sessionId = credentials.sessionId;
-            this.emit('sessionReady', this.sessionId);
-        }
-        catch (error) {
-            this.emit('error', error);
-            throw error;
-        }
-    }
-    getSessionTimeRemaining() { return this.sessionManager.getTimeUntilExpiration(); }
-    isSessionValid() { return this.sessionManager.isSessionValid(); }
-    getUsageMetrics() { return this.usageTracker?.getMetrics() || null; }
-    trackQualityScore(score) { this.usageTracker?.trackQualityScore(score); }
-    async getBillingInfo() { return this.billingMonitor.fetchBillingInfo(); }
-    getCurrentBillingInfo() { return this.billingMonitor.getCurrentBillingInfo(); }
-    setBillingWarningThresholds(thresholds) {
-        this.billingMonitor.setWarningThresholds(thresholds);
-    }
-    getConnectionState() { return this.connectionStateManager.getState(); }
-    getConnectionQuality() { return this.connectionStateManager.getQuality(); }
-    isHealthy() { return this.connectionStateManager.isHealthy(); }
-    getConnectionHistory() {
-        return this.connectionStateManager.getStateHistory();
-    }
-    getPerformanceMetrics() { return this.performanceMonitor.getMetrics(); }
-    getPerformanceBenchmarks() { return this.performanceMonitor.getBenchmarks(); }
-    recordPerformanceBenchmark(benchmark) {
-        this.performanceMonitor.recordBenchmark(benchmark);
-    }
-    recordLatency(type, latency) {
-        this.performanceMonitor.recordLatency(type, latency);
-    }
-    async reportPerformanceMetrics() { await this.performanceMonitor.reportMetrics(); }
-    setWorkerPreferences(preferences) { this.config.workerPreferences = preferences; }
-    getWorkerPreferences() { return this.config.workerPreferences; }
-    getAssignedWorkerInfo() { return this.sessionManager.getWorkerInfo() || undefined; }
-    trackEvent(eventType, metadata) {
-        this.analyticsCollector.trackEvent(eventType, metadata);
-    }
-    getSessionAnalytics() { return this.analyticsCollector.getSessionAnalytics(); }
-    async flushAnalytics() { await this.analyticsCollector.flush(); }
-    async destroy() {
-        await this.disconnect();
-        this.sessionManager.destroy();
-        this.billingMonitor.destroy();
-        this.connectionStateManager.destroy();
-        this.performanceMonitor.destroy();
-        this.analyticsCollector.destroy();
-        await this.securityLogger.destroy();
-        this.removeAllListeners();
-    }
-}
-
-function useAStack(options) {
-    const clientRef = react.useRef(null);
-    const [isConnected, setIsConnected] = react.useState(false);
-    const [isConnecting, setIsConnecting] = react.useState(false);
-    const [sessionStatus, setSessionStatus] = react.useState({
-        id: '',
-        status: 'pending',
-        connectionState: 'disconnected',
-        iceConnectionState: 'new'
-    });
-    const [error, setError] = react.useState(null);
-    const [localStream, setLocalStream] = react.useState(null);
-    const [remoteStream, setRemoteStream] = react.useState(null);
-    const [messages, setMessages] = react.useState([]);
-    react.useEffect(() => {
-        if (!clientRef.current) {
-            const client = new AStackClient(options);
-            clientRef.current = client;
-            client.on('connected', () => {
-                setIsConnected(true);
-                setIsConnecting(false);
-                setError(null);
-            });
-            client.on('disconnected', () => {
-                setIsConnected(false);
-                setIsConnecting(false);
-            });
-            client.on('error', (err) => {
-                setError(err);
-                setIsConnecting(false);
-            });
-            client.on('sessionReady', (sessionId) => {
-                setSessionStatus(prev => ({ ...prev, id: sessionId, status: 'connected' }));
-            });
-            client.on('connectionStateChange', (state) => {
-                setSessionStatus(prev => ({ ...prev, connectionState: state }));
-            });
-            client.on('iceConnectionStateChange', (state) => {
-                setSessionStatus(prev => ({ ...prev, iceConnectionState: state }));
-            });
-            client.on('localStreamAdded', (stream) => {
-                setLocalStream(stream);
-            });
-            client.on('remoteStreamAdded', (stream) => {
-                setRemoteStream(stream);
-            });
-            client.on('messageReceived', (response) => {
-                setMessages(prev => [...prev, response]);
-            });
-            client.on('reconnecting', (attempt) => {
-                setIsConnecting(true);
-                setError(null);
-            });
-        }
-        return () => {
-            if (clientRef.current) {
-                clientRef.current.disconnect();
-                clientRef.current = null;
-            }
-        };
-    }, []);
-    react.useEffect(() => {
-        if (options.autoConnect && clientRef.current && !isConnected && !isConnecting) {
-            connect();
-        }
-    }, [options.autoConnect]);
-    react.useEffect(() => {
-        if (isConnected && clientRef.current) {
-            if (options.autoStartAudio) {
-                startAudio();
-            }
-            if (options.autoStartVideo) {
-                startVideo();
-            }
-        }
-    }, [isConnected, options.autoStartAudio, options.autoStartVideo]);
-    const connect = react.useCallback(async () => {
-        if (!clientRef.current || isConnected || isConnecting)
-            return;
-        setIsConnecting(true);
-        setError(null);
-        try {
-            await clientRef.current.connect();
-        }
-        catch (err) {
-            setError(err);
-            setIsConnecting(false);
-        }
-    }, [isConnected, isConnecting]);
-    const disconnect = react.useCallback(async () => {
-        if (!clientRef.current)
-            return;
-        try {
-            await clientRef.current.disconnect();
-            setIsConnected(false);
-            setIsConnecting(false);
-            setLocalStream(null);
-            setRemoteStream(null);
-            setError(null);
-        }
-        catch (err) {
-            setError(err);
-        }
-    }, []);
-    const sendMessage = react.useCallback(async (text) => {
-        if (!clientRef.current)
-            throw new Error('Client not initialized');
-        await clientRef.current.sendText(text);
-    }, []);
-    const sendAudio = react.useCallback(async (audioBlob) => {
-        if (!clientRef.current)
-            throw new Error('Client not initialized');
-        await clientRef.current.sendAudio(audioBlob);
-    }, []);
-    const startAudio = react.useCallback(async () => {
-        if (!clientRef.current)
-            throw new Error('Client not initialized');
-        try {
-            const stream = await clientRef.current.startAudio();
-            setLocalStream(stream);
-        }
-        catch (err) {
-            setError(err);
-        }
-    }, []);
-    const stopAudio = react.useCallback(async () => {
-        if (!clientRef.current)
-            return;
-        try {
-            await clientRef.current.stopAudio();
-        }
-        catch (err) {
-            setError(err);
-        }
-    }, []);
-    const startVideo = react.useCallback(async () => {
-        if (!clientRef.current)
-            throw new Error('Client not initialized');
-        try {
-            const stream = await clientRef.current.startVideo();
-            setLocalStream(stream);
-        }
-        catch (err) {
-            setError(err);
-        }
-    }, []);
-    const stopVideo = react.useCallback(async () => {
-        if (!clientRef.current)
-            return;
-        try {
-            await clientRef.current.stopVideo();
-        }
-        catch (err) {
-            setError(err);
-        }
-    }, []);
-    const startRecording = react.useCallback(() => {
-        if (!clientRef.current)
-            throw new Error('Client not initialized');
-        clientRef.current.startRecording();
-    }, []);
-    const stopRecording = react.useCallback(() => {
-        if (!clientRef.current)
-            return;
-        clientRef.current.stopRecording();
-    }, []);
-    const muteAudio = react.useCallback(() => {
-        if (!clientRef.current)
-            return;
-        clientRef.current.muteAudio();
-    }, []);
-    const unmuteAudio = react.useCallback(() => {
-        if (!clientRef.current)
-            return;
-        clientRef.current.unmuteAudio();
-    }, []);
-    const pauseVideo = react.useCallback(() => {
-        if (!clientRef.current)
-            return;
-        clientRef.current.pauseVideo();
-    }, []);
-    const resumeVideo = react.useCallback(() => {
-        if (!clientRef.current)
-            return;
-        clientRef.current.resumeVideo();
-    }, []);
-    const clearMessages = react.useCallback(() => {
-        setMessages([]);
-    }, []);
-    return {
-        client: clientRef.current,
-        isConnected,
-        isConnecting,
-        sessionStatus,
-        error,
-        localStream,
-        remoteStream,
-        messages,
-        connect,
-        disconnect,
-        sendMessage,
-        sendAudio,
-        startAudio,
-        stopAudio,
-        startVideo,
-        stopVideo,
-        startRecording,
-        stopRecording,
-        muteAudio,
-        unmuteAudio,
-        pauseVideo,
-        resumeVideo,
-        clearMessages
-    };
-}
-
 const ARKIT_BLENDSHAPES = [
     'jawOpen', 'jawForward', 'jawLeft', 'jawRight',
     'mouthClose', 'mouthFunnel', 'mouthPucker', 'mouthLeft', 'mouthRight',
@@ -2071,12 +45,17 @@ const ARKIT_BLENDSHAPES = [
 ];
 const BLENDSHAPE_COUNT = 52;
 
+const IDX_JAW_OPEN = ARKIT_BLENDSHAPES.indexOf('jawOpen');
+const IDX_MOUTH_FUNNEL = ARKIT_BLENDSHAPES.indexOf('mouthFunnel');
+const IDX_MOUTH_LOWER_DOWN_LEFT = ARKIT_BLENDSHAPES.indexOf('mouthLowerDownLeft');
+const IDX_MOUTH_LOWER_DOWN_RIGHT = ARKIT_BLENDSHAPES.indexOf('mouthLowerDownRight');
 class AudioPlayer extends eventemitter3.EventEmitter {
     constructor(sampleRate = 24000) {
         super();
         this.audioContext = null;
         this.audioQueue = [];
         this.isPlaying = false;
+        this.animationFrameId = null;
         this.sampleRate = sampleRate;
     }
     async ensureAudioContext() {
@@ -2089,16 +68,18 @@ class AudioPlayer extends eventemitter3.EventEmitter {
         return this.audioContext;
     }
     enqueue(chunk) {
-        console.log('[AudioPlayer] Enqueue called, queue length before:', this.audioQueue.length, 'isPlaying:', this.isPlaying);
         this.audioQueue.push(chunk);
         if (!this.isPlaying) {
-            console.log('[AudioPlayer] Not playing, starting playNext');
             this.playNext();
         }
     }
     clearQueue() {
         this.audioQueue = [];
         this.isPlaying = false;
+        if (this.animationFrameId !== null) {
+            cancelAnimationFrame(this.animationFrameId);
+            this.animationFrameId = null;
+        }
         this.emit('blendshapeUpdate', new Array(BLENDSHAPE_COUNT).fill(0));
     }
     async playNext() {
@@ -2125,33 +106,28 @@ class AudioPlayer extends eventemitter3.EventEmitter {
             const jawOpen = Math.min(amplitude * 3, 1);
             const mouthOpen = Math.min(amplitude * 2.5, 0.8);
             const frameData = new Array(BLENDSHAPE_COUNT).fill(0);
-            frameData[25] = jawOpen; // jawOpen
-            frameData[27] = mouthOpen; // mouthFunnel
-            frameData[29] = mouthOpen * 0.3; // mouthLowerDownLeft
-            frameData[30] = mouthOpen * 0.3; // mouthLowerDownRight
+            frameData[IDX_JAW_OPEN] = jawOpen;
+            frameData[IDX_MOUTH_FUNNEL] = mouthOpen;
+            frameData[IDX_MOUTH_LOWER_DOWN_LEFT] = mouthOpen * 0.3;
+            frameData[IDX_MOUTH_LOWER_DOWN_RIGHT] = mouthOpen * 0.3;
             blendshapes.push(frameData);
         }
         return blendshapes;
     }
     async playChunk(chunk) {
         try {
-            console.log('[AudioPlayer] playChunk called, audio byteLength:', chunk.audio.byteLength);
             const ctx = await this.ensureAudioContext();
-            console.log('[AudioPlayer] AudioContext state:', ctx.state, 'sampleRate:', ctx.sampleRate);
             const int16Array = new Int16Array(chunk.audio);
             const floatArray = new Float32Array(int16Array.length);
             for (let i = 0; i < int16Array.length; i++) {
                 floatArray[i] = int16Array[i] / 32768.0;
             }
-            console.log('[AudioPlayer] Converted to float, samples:', floatArray.length);
             const audioBuffer = ctx.createBuffer(1, floatArray.length, this.sampleRate);
             audioBuffer.getChannelData(0).set(floatArray);
             const source = ctx.createBufferSource();
             source.buffer = audioBuffer;
             source.connect(ctx.destination);
-            console.log('[AudioPlayer] Audio buffer duration:', audioBuffer.duration, 'seconds');
             const hasBlendshapes = chunk.blendshapes && chunk.blendshapes.length > 0;
-            console.log('[AudioPlayer] Has blendshapes:', hasBlendshapes, 'generating amplitude fallback:', !hasBlendshapes);
             const blendshapes = hasBlendshapes
                 ? chunk.blendshapes
                 : this.generateAmplitudeBlendshapes(floatArray);
@@ -2161,8 +137,13 @@ class AudioPlayer extends eventemitter3.EventEmitter {
             this.isPlaying = true;
             this.emit('playbackStarted');
             const animate = () => {
+                if (!this.isPlaying) {
+                    this.animationFrameId = null;
+                    return;
+                }
                 const elapsed = performance.now() - startTime;
                 if (elapsed >= duration || frameIndex >= blendshapes.length) {
+                    this.animationFrameId = null;
                     this.emit('blendshapeUpdate', new Array(BLENDSHAPE_COUNT).fill(0));
                     this.emit('playbackEnded');
                     this.playNext();
@@ -2177,11 +158,10 @@ class AudioPlayer extends eventemitter3.EventEmitter {
                         this.emit('blendshapeUpdate', frame);
                     }
                 }
-                requestAnimationFrame(animate);
+                this.animationFrameId = requestAnimationFrame(animate);
             };
-            console.log('[AudioPlayer] Starting audio playback');
             source.start();
-            requestAnimationFrame(animate);
+            this.animationFrameId = requestAnimationFrame(animate);
         }
         catch (err) {
             console.error('[AudioPlayer] Error in playChunk:', err);
@@ -2212,15 +192,24 @@ class AStackCSRClient extends eventemitter3.EventEmitter {
         this.imageCaptureInterval = null;
         this.callStatus = 'idle';
         this.currentBlendshapes = new Array(BLENDSHAPE_COUNT).fill(0);
+        this.reconnectAttempts = 0;
+        this.reconnectTimer = null;
+        this.intentionalClose = false;
+        this.hasConnected = false;
+        this.clientId = null;
+        this.pendingAuth = null;
         this.config = {
             workerUrl: config.workerUrl,
             sessionToken: config.sessionToken || '',
-            sessionId: config.sessionId || '',
             sampleRate: config.sampleRate || 24000,
-            providers: config.providers || { asr: 'self', llm: 'self', tts: 'self' },
             fps: config.fps || 30,
             enableImageCapture: config.enableImageCapture ?? true,
-            imageCaptureInterval: config.imageCaptureInterval || 5000
+            imageCaptureInterval: config.imageCaptureInterval || 5000,
+            autoReconnect: config.autoReconnect ?? true,
+            maxRetries: config.maxRetries ?? 5,
+            reconnectDelay: config.reconnectDelay ?? 1000,
+            audioProcessorUrl: config.audioProcessorUrl || '/audio-processor.js',
+            debug: config.debug ?? false,
         };
         this.audioPlayer = new AudioPlayer(this.config.sampleRate);
         this.setupAudioPlayerEvents();
@@ -2241,32 +230,93 @@ class AStackCSRClient extends eventemitter3.EventEmitter {
         });
     }
     async connect() {
+        this.intentionalClose = false;
+        return this.connectInternal(false);
+    }
+    connectInternal(isReconnect) {
         return new Promise((resolve, reject) => {
             const wsUrl = this.config.workerUrl.replace(/^http/, 'ws');
             const url = new URL(wsUrl);
-            if (this.config.sessionToken) {
-                url.searchParams.set('token', this.config.sessionToken);
-            }
-            if (this.config.sessionId) {
-                url.searchParams.set('sessionId', this.config.sessionId);
+            if (url.protocol === 'ws:') {
+                console.warn('[CSR] Connecting over unencrypted ws:// — use wss:// in production');
             }
+            const timeout = setTimeout(() => {
+                if (this.ws) {
+                    this.ws.close();
+                    this.ws = null;
+                }
+                const error = new Error('WebSocket connection timeout');
+                this.emit('error', error);
+                if (!isReconnect)
+                    reject(error);
+            }, 30000);
             this.ws = new WebSocket(url.toString());
             this.ws.onopen = () => {
-                this.emit('connected');
-                resolve();
+                this.pendingAuth = {
+                    resolve: () => {
+                        clearTimeout(timeout);
+                        this.reconnectAttempts = 0;
+                        this.hasConnected = true;
+                        if (isReconnect) {
+                            if (this.callStatus === 'active' || this.callStatus === 'starting') {
+                                this.stopCall();
+                                this.emit('callStopped');
+                            }
+                            this.emit('reconnected');
+                        }
+                        else {
+                            this.emit('connected');
+                        }
+                        resolve();
+                    },
+                    reject: (err) => {
+                        clearTimeout(timeout);
+                        this.pendingAuth = null;
+                        if (this.ws) {
+                            this.ws.close();
+                            this.ws = null;
+                        }
+                        this.emit('error', err);
+                        if (!isReconnect)
+                            reject(err);
+                    }
+                };
+                this.sendAuthentication();
             };
             this.ws.onclose = () => {
-                this.emit('disconnected');
-                this.callStatus = 'idle';
+                clearTimeout(timeout);
+                this.ws = null;
+                if (this.pendingAuth) {
+                    this.pendingAuth.reject(new Error('WebSocket closed before authentication completed'));
+                    this.pendingAuth = null;
+                }
+                if (this.intentionalClose) {
+                    this.stopCall();
+                    this.emit('disconnected');
+                    return;
+                }
+                if (this.hasConnected && this.config.autoReconnect) {
+                    this.attemptReconnect();
+                }
+                else {
+                    this.stopCall();
+                    this.emit('disconnected');
+                }
             };
-            this.ws.onerror = (event) => {
+            this.ws.onerror = (_event) => {
+                clearTimeout(timeout);
                 const error = new Error('WebSocket connection error');
                 this.emit('error', error);
-                reject(error);
+                if (!isReconnect)
+                    reject(error);
             };
             this.ws.onmessage = (event) => {
                 try {
                     const data = JSON.parse(event.data);
+                    if (!data || typeof data !== 'object' || typeof data.type !== 'string') {
+                        console.error('[CSR] Invalid message: missing type');
+                        return;
+                    }
                     this.handleMessage(data);
                 }
                 catch (err) {
@@ -2275,43 +325,123 @@ class AStackCSRClient extends eventemitter3.EventEmitter {
             };
         });
     }
+    sendAuthentication() {
+        if (!this.config.sessionToken) {
+            if (this.pendingAuth) {
+                this.pendingAuth.reject(new Error('Missing sessionToken in config'));
+            }
+            return;
+        }
+        if (this.ws) {
+            this.ws.send(JSON.stringify({
+                type: 'authenticate',
+                sessionToken: this.config.sessionToken
+            }));
+        }
+    }
+    attemptReconnect() {
+        if (this.reconnectAttempts >= this.config.maxRetries) {
+            this.stopCall();
+            this.emit('error', new Error('Maximum reconnection attempts reached'));
+            this.emit('disconnected');
+            return;
+        }
+        this.reconnectAttempts++;
+        const delay = this.config.reconnectDelay * Math.pow(2, this.reconnectAttempts - 1);
+        this.emit('reconnecting', this.reconnectAttempts);
+        this.reconnectTimer = setTimeout(async () => {
+            this.reconnectTimer = null;
+            try {
+                await this.connectInternal(true);
+            }
+            catch {
+                this.attemptReconnect();
+            }
+        }, delay);
+    }
     handleMessage(data) {
-        console.log('[CSR] Received message:', data.type);
+        if (this.config.debug)
+            console.log('[CSR] Received message:', data.type);
         switch (data.type) {
-            case 'a2f_call_started':
+            case 'connected':
+                if (typeof data.clientId === 'string')
+                    this.clientId = data.clientId;
+                break;
+            case 'authenticated':
+                if (this.pendingAuth) {
+                    this.pendingAuth.resolve();
+                    this.pendingAuth = null;
+                }
+                break;
+            case 'auth_error': {
+                const msg = typeof data.message === 'string' ? data.message : 'Authentication failed';
+                if (this.pendingAuth) {
+                    this.pendingAuth.reject(new Error(msg));
+                    this.pendingAuth = null;
+                }
+                else {
+                    this.emit('error', new Error(msg));
+                }
+                break;
+            }
+            case 'call_started':
                 this.callStatus = 'active';
                 this.emit('callStarted');
                 break;
-            case 'a2f_call_stopped':
+            case 'call_stopped':
                 this.callStatus = 'idle';
                 this.emit('callStopped');
                 break;
-            case 'a2f_call_error':
+            case 'call_error':
                 this.callStatus = 'error';
-                this.emit('error', new Error(data.message));
+                this.emit('error', new Error(typeof data.message === 'string' ? data.message : 'Unknown error'));
                 break;
-            case 'a2f_transcript':
+            case 'call_interim':
+                if (typeof data.text !== 'string')
+                    return;
+                this.emit('interim', data.text);
+                break;
+            case 'call_transcript':
+                if (typeof data.text !== 'string')
+                    return;
                 this.emit('transcript', data.text);
                 break;
-            case 'a2f_response':
+            case 'call_response':
+                if (typeof data.text !== 'string')
+                    return;
                 this.emit('response', data.text);
                 break;
+            case 'call_response_complete':
+                this.emit('responseComplete');
+                break;
+            case 'call_speech_started':
+                this.emit('speechStarted');
+                break;
+            case 'call_utterance_end':
+                this.emit('utteranceEnd');
+                break;
+            case 'call_asr_error':
+                this.emit('asrError', typeof data.message === 'string' ? data.message : 'Unknown ASR error');
+                break;
             case 'call_chunk':
-            case 'a2f_call_chunk':
-                console.log('[CSR] Audio chunk received, has audio:', !!data.audio, 'has blendshapes:', !!data.blendshapes);
-                if (data.audio) {
+                if (this.config.debug)
+                    console.log('[CSR] Audio chunk received, has audio:', !!data.audio, 'has blendshapes:', !!data.blendshapes);
+                if (typeof data.audio === 'string') {
                     try {
                         const binaryString = atob(data.audio);
                         const bytes = new Uint8Array(binaryString.length);
                         for (let i = 0; i < binaryString.length; i++) {
                             bytes[i] = binaryString.charCodeAt(i);
                         }
-                        console.log('[CSR] Decoded audio bytes:', bytes.length);
+                        if (this.config.debug)
+                            console.log('[CSR] Decoded audio bytes:', bytes.length);
+                        const blendshapes = Array.isArray(data.blendshapes) ? data.blendshapes : undefined;
                         const chunk = {
                             audio: bytes.buffer,
-                            blendshapes: data.blendshapes
+                            blendshapes
                         };
-                        console.log('[CSR] Enqueueing audio chunk');
+                        if (this.config.debug)
+                            console.log('[CSR] Enqueueing audio chunk');
                         this.audioPlayer.enqueue(chunk);
                     }
                     catch (err) {
@@ -2322,15 +452,15 @@ class AStackCSRClient extends eventemitter3.EventEmitter {
                     console.warn('[CSR] Audio chunk missing audio data');
                 }
                 break;
-            case 'a2f_model_status':
+            case 'model_status':
                 this.emit('modelStatus', {
-                    model_loaded: data.model_loaded,
-                    blendshape_count: data.blendshape_count
+                    model_loaded: typeof data.model_loaded === 'boolean' ? data.model_loaded : undefined,
+                    blendshape_count: typeof data.blendshape_count === 'number' ? data.blendshape_count : undefined
                 });
                 break;
         }
     }
-    async startCall() {
+    async startCall(options) {
         if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
             throw new Error('WebSocket not connected');
         }
@@ -2341,7 +471,7 @@ class AStackCSRClient extends eventemitter3.EventEmitter {
         this.audioPlayer.clearQueue();
         try {
             this.audioContext = new AudioContext({ sampleRate: 16000 });
-            await this.audioContext.audioWorklet.addModule('/audio-processor.js');
+            await this.audioContext.audioWorklet.addModule(this.config.audioProcessorUrl);
             this.mediaStream = await navigator.mediaDevices.getUserMedia({
                 audio: {
                     sampleRate: 16000,
@@ -2369,17 +499,22 @@ class AStackCSRClient extends eventemitter3.EventEmitter {
                 }
             }
             this.ws.send(JSON.stringify({
-                type: 'a2f_call_start',
-                providers: this.config.providers,
-                fps: this.config.fps
+                type: 'call_start',
+                fps: this.config.fps,
+                ...options
             }));
             const source = this.audioContext.createMediaStreamSource(this.mediaStream);
             this.audioProcessor = new AudioWorkletNode(this.audioContext, 'audio-processor');
             this.audioProcessor.port.onmessage = (event) => {
                 if (event.data.type === 'audio_data' && this.ws?.readyState === WebSocket.OPEN) {
-                    const base64String = btoa(String.fromCharCode(...new Uint8Array(event.data.audioBuffer)));
+                    const bytes = new Uint8Array(event.data.audioBuffer);
+                    let binary = '';
+                    for (let i = 0; i < bytes.length; i += 8192) {
+                        binary += String.fromCharCode.apply(null, bytes.subarray(i, i + 8192));
+                    }
+                    const base64String = btoa(binary);
                     this.ws.send(JSON.stringify({
-                        type: 'a2f_call_audio',
+                        type: 'call_audio',
                         audio: base64String
                     }));
                 }
@@ -2389,6 +524,22 @@ class AStackCSRClient extends eventemitter3.EventEmitter {
         }
         catch (err) {
             this.callStatus = 'error';
+            if (this.ws?.readyState === WebSocket.OPEN) {
+                this.ws.send(JSON.stringify({ type: 'call_stop' }));
+            }
+            if (this.mediaStream) {
+                this.mediaStream.getTracks().forEach(track => track.stop());
+                this.mediaStream = null;
+            }
+            if (this.audioContext) {
+                this.audioContext.close();
+                this.audioContext = null;
+            }
+            if (this.videoRef) {
+                this.videoRef.srcObject = null;
+                this.videoRef = null;
+            }
+            this.imageCaptureCanvas = null;
             throw err;
         }
     }
@@ -2416,7 +567,7 @@ class AStackCSRClient extends eventemitter3.EventEmitter {
         const imageDataUrl = this.imageCaptureCanvas.toDataURL('image/jpeg', 0.7);
         const base64Image = imageDataUrl.split(',')[1];
         this.ws.send(JSON.stringify({
-            type: 'a2f_call_image',
+            type: 'call_image',
             image: base64Image,
             timestamp: Date.now()
         }));
@@ -2427,7 +578,7 @@ class AStackCSRClient extends eventemitter3.EventEmitter {
             this.imageCaptureInterval = null;
         }
         if (this.ws?.readyState === WebSocket.OPEN) {
-            this.ws.send(JSON.stringify({ type: 'a2f_call_stop' }));
+            this.ws.send(JSON.stringify({ type: 'call_stop' }));
         }
         if (this.videoRef) {
             this.videoRef.srcObject = null;
@@ -2456,17 +607,39 @@ class AStackCSRClient extends eventemitter3.EventEmitter {
             throw new Error('WebSocket not connected');
         }
         this.ws.send(JSON.stringify({
-            type: 'a2f_text_message',
+            type: 'call_text_input',
             text: message
         }));
     }
-    disconnect() {
+    async disconnect() {
+        this.intentionalClose = true;
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+            this.reconnectTimer = null;
+        }
+        this.reconnectAttempts = 0;
         this.stopCall();
         if (this.ws) {
+            await this.waitForFlush(this.ws);
             this.ws.close();
             this.ws = null;
         }
     }
+    waitForFlush(ws, timeoutMs = 100) {
+        if (ws.bufferedAmount === 0)
+            return Promise.resolve();
+        return new Promise((resolve) => {
+            const start = Date.now();
+            const check = () => {
+                if (ws.bufferedAmount === 0 || Date.now() - start >= timeoutMs) {
+                    resolve();
+                    return;
+                }
+                setTimeout(check, 10);
+            };
+            check();
+        });
+    }
     getCallStatus() {
         return this.callStatus;
     }
@@ -2476,8 +649,11 @@ class AStackCSRClient extends eventemitter3.EventEmitter {
     isConnected() {
         return this.ws?.readyState === WebSocket.OPEN;
     }
+    getReconnectAttempts() {
+        return this.reconnectAttempts;
+    }
     async destroy() {
-        this.disconnect();
+        await this.disconnect();
         await this.audioPlayer.destroy();
         this.removeAllListeners();
     }
@@ -2527,7 +703,7 @@ function useAStackCSR(options) {
             client.destroy();
             clientRef.current = null;
         };
-    }, [options.workerUrl]);
+    }, [options.workerUrl, options.sessionToken]);
     const connect = react.useCallback(async () => {
         if (clientRef.current) {
             await clientRef.current.connect();
@@ -2792,7 +968,7 @@ function TalkingHeadAvatar({ blendshapes, width = 400, height = 400, avatarUrl =
       "three/addons/": "https://cdn.jsdelivr.net/npm/three@0.180.0/examples/jsm/"
     }
   }
-  <\/script>
+  ${"</"}script>
 </head>
 <body>
   <div id="avatar"></div>
@@ -2881,7 +1057,7 @@ function TalkingHeadAvatar({ blendshapes, width = 400, height = 400, avatarUrl =
     });
 
     init();
-  <\/script>
+  ${"</"}script>
 </body>
 </html>
   `)}`;
@@ -2890,6 +1066,4 @@ function TalkingHeadAvatar({ blendshapes, width = 400, height = 400, avatarUrl =
 
 exports.TalkingHeadAvatar = TalkingHeadAvatar;
 exports.VRMAvatar = VRMAvatar;
-exports.useAStack = useAStack;
 exports.useAStackCSR = useAStackCSR;
-//# sourceMappingURL=react.js.map