@anam-ai/js-sdk 4.8.0-alpha.sam.0 → 4.8.0-alpha.sam.1

package/dist/module/modules/StreamingClient.js

@@ -1,706 +0,0 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-import { ClientMetricMeasurement, createRTCStatsReport, sendClientMetric, } from '../lib/ClientMetrics';
-import { EngineApiRestClient, SignallingClient, ToolCallManager, } from '../modules';
-import { AnamEvent, AudioPermissionState, ConnectionClosedCode, DataChannelMessage, InternalEvent, SignalMessageAction, } from '../types';
-import { AgentAudioInputStream } from '../types/AgentAudioInputStream';
-import { TalkMessageStream } from '../types/TalkMessageStream';
-const SUCCESS_METRIC_POLLING_TIMEOUT_MS = 15000; // After this time we will stop polling for the first frame and consider the session a failure.
-const STATS_COLLECTION_INTERVAL_MS = 5000;
-const ICE_CANDIDATE_POOL_SIZE = 2; // Optimisation to speed up connection time
-export class StreamingClient {
-    constructor(sessionId, options, publicEventEmitter, internalEventEmitter) {
-        var _a, _b, _c, _d;
-        this.peerConnection = null;
-        this.connectionReceivedAnswer = false;
-        this.remoteIceCandidateBuffer = [];
-        this.inputAudioStream = null;
-        this.dataChannel = null;
-        this.videoElement = null;
-        this.videoStream = null;
-        this.audioStream = null;
-        this.inputAudioState = {
-            isMuted: false,
-            permissionState: AudioPermissionState.NOT_REQUESTED,
-        };
-        this.successMetricPoller = null;
-        this.successMetricFired = false;
-        this.showPeerConnectionStatsReport = false;
-        this.peerConnectionStatsReportOutputFormat = 'console';
-        this.statsCollectionInterval = null;
-        this.agentAudioInputStream = null;
-        this.publicEventEmitter = publicEventEmitter;
-        this.internalEventEmitter = internalEventEmitter;
-        this.apiGatewayConfig = options.apiGateway;
-        // initialize input audio state
-        const { inputAudio } = options;
-        this.inputAudioState = inputAudio.inputAudioState;
-        if (options.inputAudio.userProvidedMediaStream) {
-            this.inputAudioStream = options.inputAudio.userProvidedMediaStream;
-        }
-        this.disableInputAudio = options.inputAudio.disableInputAudio === true;
-        // register event handlers
-        this.internalEventEmitter.addListener(InternalEvent.WEB_SOCKET_OPEN, this.onSignallingClientConnected.bind(this));
-        this.internalEventEmitter.addListener(InternalEvent.SIGNAL_MESSAGE_RECEIVED, this.onSignalMessage.bind(this));
-        // set ice servers
-        this.iceServers = options.iceServers;
-        // initialize signalling client
-        this.signallingClient = new SignallingClient(sessionId, options.signalling, this.publicEventEmitter, this.internalEventEmitter, this.apiGatewayConfig);
-        // initialize engine API client
-        this.engineApiRestClient = new EngineApiRestClient(options.engine.baseUrl, sessionId, this.apiGatewayConfig);
-        this.audioDeviceId = options.inputAudio.audioDeviceId;
-        this.showPeerConnectionStatsReport =
-            (_b = (_a = options.metrics) === null || _a === void 0 ? void 0 : _a.showPeerConnectionStatsReport) !== null && _b !== void 0 ? _b : false;
-        this.peerConnectionStatsReportOutputFormat =
-            (_d = (_c = options.metrics) === null || _c === void 0 ? void 0 : _c.peerConnectionStatsReportOutputFormat) !== null && _d !== void 0 ? _d : 'console';
-    }
-    onInputAudioStateChange(oldState, newState) {
-        // changed microphone mute state
-        if (oldState.isMuted !== newState.isMuted) {
-            if (newState.isMuted) {
-                this.muteAllAudioTracks();
-            }
-            else {
-                this.unmuteAllAudioTracks();
-            }
-        }
-    }
-    muteAllAudioTracks() {
-        var _a;
-        (_a = this.inputAudioStream) === null || _a === void 0 ? void 0 : _a.getAudioTracks().forEach((track) => {
-            track.enabled = false;
-        });
-    }
-    unmuteAllAudioTracks() {
-        var _a;
-        (_a = this.inputAudioStream) === null || _a === void 0 ? void 0 : _a.getAudioTracks().forEach((track) => {
-            track.enabled = true;
-        });
-    }
-    startStatsCollection() {
-        if (this.statsCollectionInterval) {
-            return;
-        }
-        // Send stats every STATS_COLLECTION_INTERVAL_MS seconds
-        this.statsCollectionInterval = setInterval(() => __awaiter(this, void 0, void 0, function* () {
-            if (!this.peerConnection ||
-                !this.dataChannel ||
-                this.dataChannel.readyState !== 'open') {
-                return;
-            }
-            try {
-                const stats = yield this.peerConnection.getStats();
-                this.sendClientSideMetrics(stats);
-            }
-            catch (error) {
-                console.error('Failed to collect and send stats:', error);
-            }
-        }), STATS_COLLECTION_INTERVAL_MS);
-    }
-    sendClientSideMetrics(stats) {
-        stats.forEach((report) => {
-            // Process inbound-rtp stats for both video and audio
-            if (report.type === 'inbound-rtp') {
-                const metrics = {
-                    message_type: 'remote_rtp_stats',
-                    data: report,
-                };
-                // Send the metrics via data channel
-                if (this.dataChannel && this.dataChannel.readyState === 'open') {
-                    this.dataChannel.send(JSON.stringify(metrics));
-                }
-            }
-        });
-    }
-    startSuccessMetricPolling() {
-        if (this.successMetricPoller || this.successMetricFired) {
-            return;
-        }
-        const timeoutId = setTimeout(() => {
-            if (this.successMetricPoller) {
-                console.warn('No video frames received, there is a problem with the connection.');
-                clearInterval(this.successMetricPoller);
-                this.successMetricPoller = null;
-            }
-        }, SUCCESS_METRIC_POLLING_TIMEOUT_MS);
-        this.successMetricPoller = setInterval(() => __awaiter(this, void 0, void 0, function* () {
-            if (!this.peerConnection || this.successMetricFired) {
-                if (this.successMetricPoller) {
-                    clearInterval(this.successMetricPoller);
-                }
-                clearTimeout(timeoutId);
-                return;
-            }
-            try {
-                const stats = yield this.peerConnection.getStats();
-                let videoDetected = false;
-                let detectionMethod = null;
-                stats.forEach((report) => {
-                    // Find the report for inbound video
-                    if (report.type === 'inbound-rtp' && report.kind === 'video') {
-                        // Method 1: Try framesDecoded (most reliable when available)
-                        if (report.framesDecoded !== undefined &&
-                            report.framesDecoded > 0) {
-                            videoDetected = true;
-                            detectionMethod = 'framesDecoded';
-                        }
-                        else if (report.framesReceived !== undefined &&
-                            report.framesReceived > 0) {
-                            videoDetected = true;
-                            detectionMethod = 'framesReceived';
-                        }
-                        else if (report.bytesReceived > 0 &&
-                            report.packetsReceived > 0 &&
-                            // Additional check: ensure we've received enough data for actual video
-                            report.bytesReceived > 100000 // rough threshold
-                        ) {
-                            videoDetected = true;
-                            detectionMethod = 'bytesReceived';
-                        }
-                    }
-                });
-                if (videoDetected && !this.successMetricFired) {
-                    this.successMetricFired = true;
-                    sendClientMetric(ClientMetricMeasurement.CLIENT_METRIC_MEASUREMENT_SESSION_SUCCESS, '1', detectionMethod ? { detectionMethod } : undefined);
-                    if (this.successMetricPoller) {
-                        clearInterval(this.successMetricPoller);
-                    }
-                    clearTimeout(timeoutId);
-                    this.successMetricPoller = null;
-                }
-            }
-            catch (error) { }
-        }), 500);
-    }
-    muteInputAudio() {
-        const oldAudioState = this.inputAudioState;
-        const newAudioState = Object.assign(Object.assign({}, this.inputAudioState), { isMuted: true });
-        this.inputAudioState = newAudioState;
-        this.onInputAudioStateChange(oldAudioState, newAudioState);
-        return this.inputAudioState;
-    }
-    unmuteInputAudio() {
-        const oldAudioState = this.inputAudioState;
-        const newAudioState = Object.assign(Object.assign({}, this.inputAudioState), { isMuted: false });
-        this.inputAudioState = newAudioState;
-        this.onInputAudioStateChange(oldAudioState, newAudioState);
-        return this.inputAudioState;
-    }
-    getInputAudioState() {
-        return this.inputAudioState;
-    }
-    getPeerConnection() {
-        return this.peerConnection;
-    }
-    changeAudioInputDevice(deviceId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.peerConnection) {
-                throw new Error('StreamingClient - changeAudioInputDevice: peer connection is not initialized. Start streaming first.');
-            }
-            if (deviceId === null || deviceId === undefined) {
-                throw new Error('StreamingClient - changeAudioInputDevice: deviceId is required');
-            }
-            // Store the current mute state to preserve it
-            const wasMuted = this.inputAudioState.isMuted;
-            try {
-                // Stop the current audio stream tracks
-                if (this.inputAudioStream) {
-                    this.inputAudioStream.getAudioTracks().forEach((track) => {
-                        track.stop();
-                    });
-                }
-                // Request new audio stream with the new device ID
-                const audioConstraints = {
-                    echoCancellation: true,
-                    deviceId: {
-                        exact: deviceId,
-                    },
-                };
-                this.inputAudioStream = yield navigator.mediaDevices.getUserMedia({
-                    audio: audioConstraints,
-                });
-                // Update the stored device ID
-                this.audioDeviceId = deviceId;
-                // Replace the audio track in the peer connection
-                yield this.setupAudioTrack();
-                // Restore the mute state
-                if (wasMuted) {
-                    this.muteAllAudioTracks();
-                }
-                // Emit event to notify that the device has changed
-                this.publicEventEmitter.emit(AnamEvent.INPUT_AUDIO_DEVICE_CHANGED, deviceId);
-            }
-            catch (error) {
-                console.error('Failed to change audio input device:', error);
-                throw new Error(`StreamingClient - changeAudioInputDevice: ${error instanceof Error ? error.message : String(error)}`);
-            }
-        });
-    }
-    getInputAudioStream() {
-        return this.inputAudioStream;
-    }
-    getVideoStream() {
-        return this.videoStream;
-    }
-    getAudioStream() {
-        return this.audioStream;
-    }
-    sendDataMessage(message) {
-        if (this.dataChannel && this.dataChannel.readyState === 'open') {
-            this.dataChannel.send(message);
-        }
-    }
-    setMediaStreamTargetById(videoElementId) {
-        // set up streaming targets
-        if (videoElementId) {
-            const videoElement = document.getElementById(videoElementId);
-            if (!videoElement) {
-                throw new Error(`StreamingClient: video element with id ${videoElementId} not found`);
-            }
-            this.videoElement = videoElement;
-        }
-    }
-    startConnection() {
-        try {
-            if (this.peerConnection) {
-                console.error('StreamingClient - startConnection: peer connection already exists');
-                return;
-            }
-            // start the connection
-            this.signallingClient.connect();
-        }
-        catch (error) {
-            console.error('StreamingClient - startConnection: error', error);
-            this.handleWebrtcFailure(error);
-        }
-    }
-    stopConnection() {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.shutdown();
-        });
-    }
-    sendTalkCommand(content) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.peerConnection) {
-                throw new Error('StreamingClient - sendTalkCommand: peer connection is null');
-            }
-            yield this.engineApiRestClient.sendTalkCommand(content);
-            return;
-        });
-    }
-    startTalkMessageStream(correlationId) {
-        if (!correlationId) {
-            // generate a random correlation uuid
-            correlationId = Math.random().toString(36).substring(2, 15);
-        }
-        return new TalkMessageStream(correlationId, this.internalEventEmitter, this.signallingClient);
-    }
-    createAgentAudioInputStream(config) {
-        this.agentAudioInputStream = new AgentAudioInputStream(config, this.signallingClient);
-        return this.agentAudioInputStream;
-    }
-    getAgentAudioInputStream() {
-        return this.agentAudioInputStream;
-    }
-    initPeerConnection() {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.peerConnection = new RTCPeerConnection({
-                iceServers: this.iceServers,
-                iceCandidatePoolSize: ICE_CANDIDATE_POOL_SIZE,
-            });
-            // set event handlers
-            this.peerConnection.onicecandidate = this.onIceCandidate.bind(this);
-            this.peerConnection.oniceconnectionstatechange =
-                this.onIceConnectionStateChange.bind(this);
-            this.peerConnection.onconnectionstatechange =
-                this.onConnectionStateChange.bind(this);
-            this.peerConnection.addEventListener('track', this.onTrackEventHandler.bind(this));
-            // set up data channels
-            yield this.setupDataChannels();
-            // add transceivers
-            this.peerConnection.addTransceiver('video', { direction: 'recvonly' });
-            if (this.disableInputAudio) {
-                this.peerConnection.addTransceiver('audio', { direction: 'recvonly' });
-            }
-            else {
-                this.peerConnection.addTransceiver('audio', { direction: 'sendrecv' });
-                // Handle audio setup after transceivers are configured
-                if (this.inputAudioStream) {
-                    // User provided an audio stream, set it up immediately
-                    yield this.setupAudioTrack();
-                }
-                else {
-                    // No user stream, start microphone permission request asynchronously
-                    // Don't await - let it run in parallel with connection setup
-                    this.requestMicrophonePermissionAsync().catch((error) => {
-                        console.error('Async microphone permission request failed:', error);
-                    });
-                }
-            }
-        });
-    }
-    onSignalMessage(signalMessage) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.peerConnection) {
-                console.error('StreamingClient - onSignalMessage: peerConnection is not initialized');
-                return;
-            }
-            switch (signalMessage.actionType) {
-                case SignalMessageAction.ANSWER:
-                    const answer = signalMessage.payload;
-                    yield this.peerConnection.setRemoteDescription(answer);
-                    this.connectionReceivedAnswer = true;
-                    // flush the remote buffer
-                    this.flushRemoteIceCandidateBuffer();
-                    break;
-                case SignalMessageAction.ICE_CANDIDATE:
-                    const iceCandidateConfig = signalMessage.payload;
-                    const candidate = new RTCIceCandidate(iceCandidateConfig);
-                    if (this.connectionReceivedAnswer) {
-                        yield this.peerConnection.addIceCandidate(candidate);
-                    }
-                    else {
-                        this.remoteIceCandidateBuffer.push(candidate);
-                    }
-                    break;
-                case SignalMessageAction.END_SESSION:
-                    const reason = signalMessage.payload;
-                    this.publicEventEmitter.emit(AnamEvent.CONNECTION_CLOSED, ConnectionClosedCode.SERVER_CLOSED_CONNECTION, reason);
-                    // close the peer connection
-                    this.shutdown();
-                    break;
-                case SignalMessageAction.WARNING:
-                    const message = signalMessage.payload;
-                    console.warn('Warning received from server: ' + message);
-                    this.publicEventEmitter.emit(AnamEvent.SERVER_WARNING, message);
-                    break;
-                case SignalMessageAction.TALK_STREAM_INTERRUPTED:
-                    const chatMessage = signalMessage.payload;
-                    this.publicEventEmitter.emit(AnamEvent.TALK_STREAM_INTERRUPTED, chatMessage.correlationId);
-                    break;
-                case SignalMessageAction.SESSION_READY:
-                    const sessionId = signalMessage.sessionId;
-                    this.publicEventEmitter.emit(AnamEvent.SESSION_READY, sessionId);
-                    break;
-                case SignalMessageAction.HEARTBEAT:
-                    break;
-                default:
-                    console.warn('StreamingClient - onSignalMessage: unknown signal message action type. Is your anam-sdk version up to date?', signalMessage);
-            }
-        });
-    }
-    onSignallingClientConnected() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.peerConnection) {
-                try {
-                    yield this.initPeerConnectionAndSendOffer();
-                }
-                catch (err) {
-                    console.error('StreamingClient - onSignallingClientConnected: Error initializing peer connection', err);
-                    this.handleWebrtcFailure(err);
-                }
-            }
-        });
-    }
-    flushRemoteIceCandidateBuffer() {
-        this.remoteIceCandidateBuffer.forEach((candidate) => {
-            var _a;
-            (_a = this.peerConnection) === null || _a === void 0 ? void 0 : _a.addIceCandidate(candidate);
-        });
-        this.remoteIceCandidateBuffer = [];
-    }
-    /**
-     * ICE Candidate Trickle
-     * As each ICE candidate is gathered from the STUN server it is sent to the
-     * webRTC server immediately in an effort to reduce time to connection.
-     */
-    onIceCandidate(event) {
-        if (event.candidate) {
-            this.signallingClient.sendIceCandidate(event.candidate);
-        }
-    }
-    onIceConnectionStateChange() {
-        var _a, _b;
-        if (((_a = this.peerConnection) === null || _a === void 0 ? void 0 : _a.iceConnectionState) === 'connected' ||
-            ((_b = this.peerConnection) === null || _b === void 0 ? void 0 : _b.iceConnectionState) === 'completed') {
-            this.publicEventEmitter.emit(AnamEvent.CONNECTION_ESTABLISHED);
-            // Start collecting stats every 5 seconds
-            this.startStatsCollection();
-        }
-    }
-    onConnectionStateChange() {
-        var _a;
-        if (((_a = this.peerConnection) === null || _a === void 0 ? void 0 : _a.connectionState) === 'closed') {
-            console.error('StreamingClient - onConnectionStateChange: Connection closed');
-            this.handleWebrtcFailure('The connection to our servers was lost. Please try again.');
-        }
-    }
-    handleWebrtcFailure(err) {
-        console.error({ message: 'StreamingClient - handleWebrtcFailure: ', err });
-        if (err.name === 'NotAllowedError' && err.message === 'Permission denied') {
-            this.publicEventEmitter.emit(AnamEvent.CONNECTION_CLOSED, ConnectionClosedCode.MICROPHONE_PERMISSION_DENIED);
-        }
-        else {
-            this.publicEventEmitter.emit(AnamEvent.CONNECTION_CLOSED, ConnectionClosedCode.WEBRTC_FAILURE);
-        }
-        try {
-            this.stopConnection();
-        }
-        catch (error) {
-            console.error('StreamingClient - handleWebrtcFailure: error stopping connection', error);
-        }
-    }
-    onTrackEventHandler(event) {
-        if (event.track.kind === 'video') {
-            // start polling stats to detect successful video data received
-            this.startSuccessMetricPolling();
-            this.videoStream = event.streams[0];
-            this.publicEventEmitter.emit(AnamEvent.VIDEO_STREAM_STARTED, this.videoStream);
-            if (this.videoElement) {
-                this.videoElement.srcObject = this.videoStream;
-                const handle = this.videoElement.requestVideoFrameCallback(() => {
-                    var _a;
-                    // unregister the callback after the first frame
-                    (_a = this.videoElement) === null || _a === void 0 ? void 0 : _a.cancelVideoFrameCallback(handle);
-                    this.publicEventEmitter.emit(AnamEvent.VIDEO_PLAY_STARTED);
-                    if (!this.successMetricFired) {
-                        this.successMetricFired = true;
-                        sendClientMetric(ClientMetricMeasurement.CLIENT_METRIC_MEASUREMENT_SESSION_SUCCESS, '1', { detectionMethod: 'videoElement' });
-                    }
-                });
-            }
-        }
-        else if (event.track.kind === 'audio') {
-            this.audioStream = event.streams[0];
-            this.publicEventEmitter.emit(AnamEvent.AUDIO_STREAM_STARTED, this.audioStream);
-        }
-    }
-    /**
-     * Set up the data channels for sending and receiving messages
-     */
-    setupDataChannels() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.peerConnection) {
-                console.error('StreamingClient - setupDataChannels: peer connection is not initialized');
-                return;
-            }
-            /**
-             * Audio - Validate user-provided stream only
-             *
-             * If the user provided an audio stream, validate it has audio tracks
-             * Microphone permission request will be handled asynchronously
-             */
-            if (!this.disableInputAudio && this.inputAudioStream) {
-                // verify the user provided stream has audio tracks
-                if (!this.inputAudioStream.getAudioTracks().length) {
-                    throw new Error('StreamingClient - setupDataChannels: user provided stream does not have audio tracks');
-                }
-            }
-            /**
-             * Text
-             *
-             * Create the data channel for sending and receiving text.
-             * There is no input stream for text, instead the sending of data is triggered by a UI interaction.
-             */
-            const dataChannel = this.peerConnection.createDataChannel('session', {
-                ordered: true,
-            });
-            dataChannel.onopen = () => {
-                this.dataChannel = dataChannel !== null && dataChannel !== void 0 ? dataChannel : null;
-            };
-            dataChannel.onclose = () => { };
-            // pass text message to the message history client
-            dataChannel.onmessage = (event) => {
-                try {
-                    const message = JSON.parse(event.data);
-                    // Handle known message types
-                    switch (message.messageType) {
-                        case DataChannelMessage.SPEECH_TEXT:
-                            this.internalEventEmitter.emit(InternalEvent.WEBRTC_CHAT_MESSAGE_RECEIVED, message.data);
-                            break;
-                        case DataChannelMessage.CLIENT_TOOL_EVENT:
-                            const webRtcToolEvent = message.data;
-                            this.internalEventEmitter.emit(InternalEvent.WEBRTC_CLIENT_TOOL_EVENT_RECEIVED, webRtcToolEvent);
-                            const clientToolEvent = ToolCallManager.WebRTCClientToolEventToClientToolEvent(webRtcToolEvent);
-                            this.publicEventEmitter.emit(AnamEvent.CLIENT_TOOL_EVENT_RECEIVED, clientToolEvent);
-                            break;
-                        case DataChannelMessage.REASONING_TEXT:
-                            this.publicEventEmitter.emit(AnamEvent.REASONING_TEXT_MESSAGE_RECEIVED, message.data);
-                            break;
-                        // Unknown message types are silently ignored to maintain forward compatibility
-                        default:
-                            break;
-                    }
-                }
-                catch (error) {
-                    console.error('Failed to parse data channel message:', error);
-                }
-            };
-        });
-    }
-    /**
-     * Request microphone permission asynchronously without blocking connection
-     */
-    requestMicrophonePermissionAsync() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.inputAudioState.permissionState === AudioPermissionState.PENDING) {
-                return; // Already requesting
-            }
-            this.inputAudioState = Object.assign(Object.assign({}, this.inputAudioState), { permissionState: AudioPermissionState.PENDING });
-            this.publicEventEmitter.emit(AnamEvent.MIC_PERMISSION_PENDING);
-            try {
-                const audioConstraints = {
-                    echoCancellation: true,
-                };
-                // If an audio device ID is provided in the options, use it
-                if (this.audioDeviceId) {
-                    audioConstraints.deviceId = {
-                        exact: this.audioDeviceId,
-                    };
-                }
-                this.inputAudioStream = yield navigator.mediaDevices.getUserMedia({
-                    audio: audioConstraints,
-                });
-                this.inputAudioState = Object.assign(Object.assign({}, this.inputAudioState), { permissionState: AudioPermissionState.GRANTED });
-                this.publicEventEmitter.emit(AnamEvent.MIC_PERMISSION_GRANTED);
-                // Now add the audio track to the existing connection
-                yield this.setupAudioTrack();
-            }
-            catch (error) {
-                console.error('Failed to get microphone permission:', error);
-                this.inputAudioState = Object.assign(Object.assign({}, this.inputAudioState), { permissionState: AudioPermissionState.DENIED });
-                const errorMessage = error instanceof Error ? error.message : String(error);
-                this.publicEventEmitter.emit(AnamEvent.MIC_PERMISSION_DENIED, errorMessage);
-            }
-        });
-    }
-    /**
-     * Set up audio track and add it to the peer connection using replaceTrack
-     */
-    setupAudioTrack() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.peerConnection || !this.inputAudioStream) {
-                return;
-            }
-            // verify the stream has audio tracks
-            if (!this.inputAudioStream.getAudioTracks().length) {
-                console.error('StreamingClient - setupAudioTrack: stream does not have audio tracks');
-                return;
-            }
-            // mute the audio tracks if the user has muted the microphone
-            if (this.inputAudioState.isMuted) {
-                this.muteAllAudioTracks();
-            }
-            const audioTrack = this.inputAudioStream.getAudioTracks()[0];
-            // Find the audio sender
-            const existingSenders = this.peerConnection.getSenders();
-            const audioSender = existingSenders.find((sender) => {
-                var _a;
-                return ((_a = sender.track) === null || _a === void 0 ? void 0 : _a.kind) === 'audio' ||
-                    (sender.track === null && sender.dtmf !== null);
-            });
-            if (audioSender) {
-                // Replace existing track (or null track) with our audio track
-                try {
-                    yield audioSender.replaceTrack(audioTrack);
-                }
-                catch (error) {
-                    console.error('Failed to replace audio track:', error);
-                    // Fallback: add track normally
-                    this.peerConnection.addTrack(audioTrack, this.inputAudioStream);
-                }
-            }
-            else {
-                // No audio sender found, add track normally
-                this.peerConnection.addTrack(audioTrack, this.inputAudioStream);
-            }
-            // pass the stream to the callback
-            this.publicEventEmitter.emit(AnamEvent.INPUT_AUDIO_STREAM_STARTED, this.inputAudioStream);
-        });
-    }
-    initPeerConnectionAndSendOffer() {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.initPeerConnection();
-            if (!this.peerConnection) {
-                console.error('StreamingClient - initPeerConnectionAndSendOffer: peer connection is not initialized');
-                return;
-            }
-            // create offer and set local description
-            try {
-                const offer = yield this.peerConnection.createOffer();
-                yield this.peerConnection.setLocalDescription(offer);
-            }
-            catch (error) {
-                console.error('StreamingClient - initPeerConnectionAndSendOffer: error creating offer', error);
-            }
-            if (!this.peerConnection.localDescription) {
-                throw new Error('StreamingClient - initPeerConnectionAndSendOffer: local description is null');
-            }
-            yield this.signallingClient.sendOffer(this.peerConnection.localDescription);
-        });
-    }
-    shutdown() {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            if (this.showPeerConnectionStatsReport) {
-                const stats = yield ((_a = this.peerConnection) === null || _a === void 0 ? void 0 : _a.getStats());
-                if (stats) {
-                    const report = createRTCStatsReport(stats, this.peerConnectionStatsReportOutputFormat);
-                    if (report) {
-                        console.log(report, undefined, 2);
-                    }
-                }
-            }
-            // stop stats collection
-            if (this.statsCollectionInterval) {
-                clearInterval(this.statsCollectionInterval);
-                this.statsCollectionInterval = null;
-            }
-            // reset video frame polling
-            if (this.successMetricPoller) {
-                clearInterval(this.successMetricPoller);
-                this.successMetricPoller = null;
-            }
-            this.successMetricFired = false;
-            // stop the input audio stream
-            try {
-                if (this.inputAudioStream) {
-                    this.inputAudioStream.getTracks().forEach((track) => {
-                        track.stop();
-                    });
-                }
-                this.inputAudioStream = null;
-            }
-            catch (error) {
-                console.error('StreamingClient - shutdown: error stopping input audio stream', error);
-            }
-            // stop the signalling client
-            try {
-                this.signallingClient.stop();
-            }
-            catch (error) {
-                console.error('StreamingClient - shutdown: error stopping signallilng', error);
-            }
-            // close the peer connection
-            try {
-                if (this.peerConnection &&
-                    this.peerConnection.connectionState !== 'closed') {
-                    this.peerConnection.onconnectionstatechange = null;
-                    this.peerConnection.close();
-                    this.peerConnection = null;
-                }
-            }
-            catch (error) {
-                console.error('StreamingClient - shutdown: error closing peer connection', error);
-            }
-        });
-    }
-}
-//# sourceMappingURL=StreamingClient.js.map