@layercode/js-sdk 2.0.5 → 2.1.0

package/dist/layercode-js-sdk.esm.js

@@ -3228,6 +3228,8 @@ class StreamProcessor extends AudioWorkletProcessor {
           this.isPaused = true;
         } else if (payload.event === 'play') {
           this.isPaused = false;
+        } else if (payload.event === 'stop') {
+          this.hasInterrupted = true;
         } else {
           throw new Error(\`Unhandled event "\${payload.event}"\`);
         }
@@ -3324,6 +3326,7 @@ class WavStreamPlayer {
     this.interruptedTrackIds = {};
     this.finishedPlayingCallback = finishedPlayingCallback;
     this.isPlaying = false;
+    this.amplitudeMonitorRaf = undefined;
   }
 
   /**
@@ -3409,14 +3412,22 @@ class WavStreamPlayer {
    * @param {function} callback - Function to call with amplitude value
    */
   startAmplitudeMonitoring(callback) {
+    this.stopAmplitudeMonitoring();
     const monitor = () => {
       const amplitude = this.getAmplitude();
       callback(amplitude);
-      requestAnimationFrame(monitor);
+      this.amplitudeMonitorRaf = requestAnimationFrame(monitor);
     };
     monitor();
   }
 
+  stopAmplitudeMonitoring() {
+    if (this.amplitudeMonitorRaf !== undefined) {
+      cancelAnimationFrame(this.amplitudeMonitorRaf);
+      this.amplitudeMonitorRaf = undefined;
+    }
+  }
+
   /**
    * Starts audio streaming
    * @private
@@ -3563,11 +3574,18 @@ class WavStreamPlayer {
     return true;
   }
 
+  stop() {
+    if (this.stream) {
+      this.stream.port.postMessage({ event: 'stop' });
+    }
+  }
+
   /**
    * Disconnects the audio context and cleans up resources
    * @returns {void}
    */
   disconnect() {
+    this.stopAmplitudeMonitoring();
     if (this.stream) {
       this.stream.disconnect();
       this.stream = null;
@@ -3851,6 +3869,7 @@ class WavRecorder {
       raw: new ArrayBuffer(0),
       mono: new ArrayBuffer(0),
     };
+    this.amplitudeMonitorRaf = void 0;
   }
 
   /**
@@ -4250,14 +4269,22 @@ class WavRecorder {
    * @param {function} callback - Function to call with amplitude value
    */
   startAmplitudeMonitoring(callback) {
+    this.stopAmplitudeMonitoring();
     const monitor = () => {
       const amplitude = this.getAmplitude();
       callback(amplitude);
-      requestAnimationFrame(monitor);
+      this.amplitudeMonitorRaf = requestAnimationFrame(monitor);
     };
     monitor();
   }
 
+  stopAmplitudeMonitoring() {
+    if (this.amplitudeMonitorRaf !== void 0) {
+      cancelAnimationFrame(this.amplitudeMonitorRaf);
+      this.amplitudeMonitorRaf = void 0;
+    }
+  }
+
   /**
    * Pauses the recording
    * Keeps microphone stream open but halts storage of audio
@@ -4390,6 +4417,7 @@ class WavRecorder {
    * @returns {Promise<true>}
    */
   async quit() {
+    this.stopAmplitudeMonitoring();
     this.listenForDeviceChange(null);
     if (this.processor) {
       await this.end();
@@ -6293,6 +6321,8 @@ function arrayBufferToBase64(arrayBuffer) {
 }
 
 var _a;
+const NOOP = () => { };
+const DEFAULT_WS_URL = 'wss://api.layercode.com/v1/agents/web/websocket';
 // SDK version - updated when publishing
 const SDK_VERSION = '2.0.2';
 const ORT_WARNING_MUTE_LEVEL = 'error';
@@ -6351,27 +6381,28 @@ class LayercodeClient {
      * @param {Object} options - Configuration options
      */
     constructor(options) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p;
         this.deviceId = null;
         this.options = {
             agentId: options.agentId,
-            conversationId: options.conversationId || null,
+            conversationId: (_a = options.conversationId) !== null && _a !== void 0 ? _a : null,
             authorizeSessionEndpoint: options.authorizeSessionEndpoint,
-            metadata: options.metadata || {},
-            vadResumeDelay: options.vadResumeDelay || 500,
-            onConnect: options.onConnect || (() => { }),
-            onDisconnect: options.onDisconnect || (() => { }),
-            onError: options.onError || (() => { }),
-            onDeviceSwitched: options.onDeviceSwitched || (() => { }),
-            onDataMessage: options.onDataMessage || (() => { }),
-            onMessage: options.onMessage || (() => { }),
-            onUserAmplitudeChange: options.onUserAmplitudeChange || (() => { }),
-            onAgentAmplitudeChange: options.onAgentAmplitudeChange || (() => { }),
-            onStatusChange: options.onStatusChange || (() => { }),
-            onUserIsSpeakingChange: options.onUserIsSpeakingChange || (() => { }),
-            onMuteStateChange: options.onMuteStateChange || (() => { }),
+            metadata: (_b = options.metadata) !== null && _b !== void 0 ? _b : {},
+            vadResumeDelay: (_c = options.vadResumeDelay) !== null && _c !== void 0 ? _c : 500,
+            onConnect: (_d = options.onConnect) !== null && _d !== void 0 ? _d : NOOP,
+            onDisconnect: (_e = options.onDisconnect) !== null && _e !== void 0 ? _e : NOOP,
+            onError: (_f = options.onError) !== null && _f !== void 0 ? _f : NOOP,
+            onDeviceSwitched: (_g = options.onDeviceSwitched) !== null && _g !== void 0 ? _g : NOOP,
+            onDataMessage: (_h = options.onDataMessage) !== null && _h !== void 0 ? _h : NOOP,
+            onMessage: (_j = options.onMessage) !== null && _j !== void 0 ? _j : NOOP,
+            onUserAmplitudeChange: (_k = options.onUserAmplitudeChange) !== null && _k !== void 0 ? _k : NOOP,
+            onAgentAmplitudeChange: (_l = options.onAgentAmplitudeChange) !== null && _l !== void 0 ? _l : NOOP,
+            onStatusChange: (_m = options.onStatusChange) !== null && _m !== void 0 ? _m : NOOP,
+            onUserIsSpeakingChange: (_o = options.onUserIsSpeakingChange) !== null && _o !== void 0 ? _o : NOOP,
+            onMuteStateChange: (_p = options.onMuteStateChange) !== null && _p !== void 0 ? _p : NOOP,
         };
         this.AMPLITUDE_MONITORING_SAMPLE_RATE = 2;
-        this._websocketUrl = 'wss://api.layercode.com/v1/agents/web/websocket';
+        this._websocketUrl = DEFAULT_WS_URL;
         this.wavRecorder = new WavRecorder({ sampleRate: 8000 }); // TODO should be set my fetched agent config
         this.wavPlayer = new WavStreamPlayer({
             finishedPlayingCallback: this._clientResponseAudioReplayFinished.bind(this),
@@ -6382,7 +6413,7 @@ class LayercodeClient {
         this.status = 'disconnected';
         this.userAudioAmplitude = 0;
         this.agentAudioAmplitude = 0;
-        this.conversationId = options.conversationId || null;
+        this.conversationId = this.options.conversationId;
         this.pushToTalkActive = false;
         this.pushToTalkEnabled = false;
         this.canInterrupt = false;
@@ -6395,12 +6426,15 @@ class LayercodeClient {
         this.activeDeviceId = null;
         this.useSystemDefaultDevice = false;
         this.lastReportedDeviceId = null;
+        this.lastKnownSystemDefaultDeviceKey = null;
         this.isMuted = false;
+        this.stopPlayerAmplitude = undefined;
+        this.stopRecorderAmplitude = undefined;
+        this.deviceChangeListener = null;
         // this.audioPauseTime = null;
         // Bind event handlers
         this._handleWebSocketMessage = this._handleWebSocketMessage.bind(this);
         this._handleDataAvailable = this._handleDataAvailable.bind(this);
-        this._setupDeviceChangeListener();
     }
     _initializeVAD() {
         var _a;
@@ -6665,31 +6699,56 @@ class LayercodeClient {
      * @param {(amplitude: number) => void} updateInternalState - Function to update the internal amplitude state.
      */
     _setupAmplitudeMonitoring(source, callback, updateInternalState) {
-        // Set up amplitude monitoring only if a callback is provided
-        // Check against the default no-op function defined in the constructor options
-        if (callback !== (() => { })) {
-            let updateCounter = 0;
-            source.startAmplitudeMonitoring((amplitude) => {
-                // Only update and call callback at the specified sample rate
-                if (updateCounter >= this.AMPLITUDE_MONITORING_SAMPLE_RATE) {
-                    updateInternalState(amplitude);
+        let updateCounter = 0;
+        source.startAmplitudeMonitoring((amplitude) => {
+            // Only update and call callback at the specified sample rate
+            if (updateCounter >= this.AMPLITUDE_MONITORING_SAMPLE_RATE) {
+                updateInternalState(amplitude);
+                if (callback !== NOOP) {
                     callback(amplitude);
-                    updateCounter = 0; // Reset counter after sampling
                 }
-                updateCounter++;
-            });
+                updateCounter = 0; // Reset counter after sampling
+            }
+            updateCounter++;
+        });
+        const stop = () => { var _a; return (_a = source.stopAmplitudeMonitoring) === null || _a === void 0 ? void 0 : _a.call(source); };
+        if (source === this.wavPlayer) {
+            this.stopPlayerAmplitude = stop;
         }
+        if (source === this.wavRecorder) {
+            this.stopRecorderAmplitude = stop;
+        }
+    }
+    _stopAmplitudeMonitoring() {
+        var _a, _b;
+        (_a = this.stopPlayerAmplitude) === null || _a === void 0 ? void 0 : _a.call(this);
+        (_b = this.stopRecorderAmplitude) === null || _b === void 0 ? void 0 : _b.call(this);
+        this.stopPlayerAmplitude = undefined;
+        this.stopRecorderAmplitude = undefined;
     }
     /**
      * Connects to the Layercode agent and starts the audio conversation
      * @async
      * @returns {Promise<void>}
      */
-    async connect() {
+    async connect(opts) {
+        if (this.status === 'connecting') {
+            return;
+        }
+        if (opts === null || opts === void 0 ? void 0 : opts.newConversation) {
+            this.options.conversationId = null;
+            this.conversationId = null;
+        }
+        else if (opts === null || opts === void 0 ? void 0 : opts.conversationId) {
+            this.options.conversationId = opts.conversationId;
+            this.conversationId = opts.conversationId;
+        }
         try {
             this._setStatus('connecting');
             // Reset turn tracking for clean start
             this._resetTurnTracking();
+            this._stopAmplitudeMonitoring();
+            this._setupDeviceChangeListener();
             // Get conversation key from server
             let authorizeSessionRequestBody = {
                 agent_id: this.options.agentId,
@@ -6712,6 +6771,7 @@ class LayercodeClient {
             }
             const authorizeSessionResponseBody = await authorizeSessionResponse.json();
             this.conversationId = authorizeSessionResponseBody.conversation_id; // Save the conversation_id for use in future reconnects
+            this.options.conversationId = this.conversationId;
             // Connect WebSocket
             this.ws = new WebSocket(`${this._websocketUrl}?${new URLSearchParams({
                 client_session_key: authorizeSessionResponseBody.client_session_key,
@@ -6741,8 +6801,12 @@ class LayercodeClient {
             };
             this.ws.onclose = () => {
                 console.log('WebSocket connection closed');
-                this._setStatus('disconnected');
-                this.options.onDisconnect();
+                this.ws = null;
+                this._performDisconnectCleanup()
+                    .catch((error) => {
+                    console.error('Error during disconnect cleanup:', error);
+                    this.options.onError(error instanceof Error ? error : new Error(String(error)));
+                });
             };
             this.ws.onerror = (error) => {
                 console.error('WebSocket error:', error);
@@ -6768,30 +6832,19 @@ class LayercodeClient {
         this.currentTurnId = null;
         console.debug('Reset turn tracking state');
     }
-    async disconnect() {
-        this.deviceId = null;
-        this.activeDeviceId = null;
-        this.useSystemDefaultDevice = false;
-        this.lastReportedDeviceId = null;
-        this.recorderStarted = false;
-        this.readySent = false;
-        // Clean up VAD if it exists
-        if (this.vad) {
-            this.vad.pause();
-            this.vad.destroy();
-            this.vad = null;
+    async disconnect(opts) {
+        if (this.status === 'disconnected') {
+            return;
         }
-        this.wavRecorder.listenForDeviceChange(null);
-        this.wavRecorder.quit();
-        this.wavPlayer.disconnect();
-        // Reset turn tracking
-        this._resetTurnTracking();
-        // Close websocket and ensure status is updated
         if (this.ws) {
+            this.ws.onopen = null;
+            this.ws.onclose = null;
+            this.ws.onerror = null;
+            this.ws.onmessage = null;
             this.ws.close();
-            this._setStatus('disconnected');
-            this.options.onDisconnect();
+            this.ws = null;
         }
+        await this._performDisconnectCleanup(opts === null || opts === void 0 ? void 0 : opts.clearConversationId);
     }
     /**
      * Gets the microphone MediaStream used by this client
@@ -6889,43 +6942,106 @@ class LayercodeClient {
      * Sets up the device change event listener
      */
     _setupDeviceChangeListener() {
-        this.wavRecorder.listenForDeviceChange(async (devices) => {
-            try {
-                const defaultDevice = devices.find((device) => device.default);
-                const usingDefaultDevice = this.useSystemDefaultDevice;
-                let shouldSwitch = !this.recorderStarted;
-                if (!shouldSwitch) {
-                    if (usingDefaultDevice) {
-                        if (!defaultDevice) {
-                            shouldSwitch = true;
+        if (!this.deviceChangeListener) {
+            this.deviceChangeListener = async (devices) => {
+                try {
+                    const defaultDevice = devices.find((device) => device.default);
+                    const usingDefaultDevice = this.useSystemDefaultDevice;
+                    const previousDefaultDeviceKey = this.lastKnownSystemDefaultDeviceKey;
+                    const currentDefaultDeviceKey = this._getDeviceComparisonKey(defaultDevice);
+                    let shouldSwitch = !this.recorderStarted;
+                    if (!shouldSwitch) {
+                        if (usingDefaultDevice) {
+                            if (!defaultDevice) {
+                                shouldSwitch = true;
+                            }
+                            else if (this.activeDeviceId &&
+                                defaultDevice.deviceId !== 'default' &&
+                                defaultDevice.deviceId !== this.activeDeviceId) {
+                                shouldSwitch = true;
+                            }
+                            else if ((previousDefaultDeviceKey && previousDefaultDeviceKey !== currentDefaultDeviceKey) ||
+                                (!previousDefaultDeviceKey && !currentDefaultDeviceKey && this.recorderStarted)) {
+                                shouldSwitch = true;
+                            }
                         }
-                        else if (this.activeDeviceId &&
-                            defaultDevice.deviceId !== 'default' &&
-                            defaultDevice.deviceId !== this.activeDeviceId) {
-                            shouldSwitch = true;
+                        else {
+                            const matchesRequestedDevice = devices.some((device) => device.deviceId === this.deviceId || device.deviceId === this.activeDeviceId);
+                            shouldSwitch = !matchesRequestedDevice;
                         }
                     }
-                    else {
-                        const matchesRequestedDevice = devices.some((device) => device.deviceId === this.deviceId || device.deviceId === this.activeDeviceId);
-                        shouldSwitch = !matchesRequestedDevice;
+                    this.lastKnownSystemDefaultDeviceKey = currentDefaultDeviceKey;
+                    if (shouldSwitch) {
+                        console.debug('Selecting fallback audio input device');
+                        const fallbackDevice = defaultDevice || devices[0];
+                        if (fallbackDevice) {
+                            const fallbackId = fallbackDevice.default ? 'default' : fallbackDevice.deviceId;
+                            await this.setInputDevice(fallbackId);
+                        }
+                        else {
+                            console.warn('No alternative audio device found');
+                        }
                     }
                 }
-                if (shouldSwitch) {
-                    console.debug('Selecting fallback audio input device');
-                    const fallbackDevice = defaultDevice || devices[0];
-                    if (fallbackDevice) {
-                        const fallbackId = fallbackDevice.default ? 'default' : fallbackDevice.deviceId;
-                        await this.setInputDevice(fallbackId);
-                    }
-                    else {
-                        console.warn('No alternative audio device found');
-                    }
+                catch (error) {
+                    this.options.onError(error instanceof Error ? error : new Error(String(error)));
                 }
-            }
-            catch (error) {
-                this.options.onError(error instanceof Error ? error : new Error(String(error)));
-            }
-        });
+            };
+        }
+        this.wavRecorder.listenForDeviceChange(this.deviceChangeListener);
+    }
+    _teardownDeviceListeners() {
+        this.wavRecorder.listenForDeviceChange(null);
+    }
+    async _performDisconnectCleanup(clearConversationId) {
+        var _a, _b;
+        this.deviceId = null;
+        this.activeDeviceId = null;
+        this.useSystemDefaultDevice = false;
+        this.lastReportedDeviceId = null;
+        this.lastKnownSystemDefaultDeviceKey = null;
+        this.recorderStarted = false;
+        this.readySent = false;
+        this._stopAmplitudeMonitoring();
+        this._teardownDeviceListeners();
+        if (this.vad) {
+            this.vad.pause();
+            this.vad.destroy();
+            this.vad = null;
+        }
+        await this.wavRecorder.quit();
+        (_b = (_a = this.wavPlayer).stop) === null || _b === void 0 ? void 0 : _b.call(_a);
+        this.wavPlayer.disconnect();
+        this._resetTurnTracking();
+        if (clearConversationId) {
+            this.options.conversationId = null;
+            this.conversationId = null;
+        }
+        else {
+            this.options.conversationId = this.conversationId;
+        }
+        this.userAudioAmplitude = 0;
+        this.agentAudioAmplitude = 0;
+        this._setStatus('disconnected');
+        this.options.onDisconnect();
+    }
+    _getDeviceComparisonKey(device) {
+        if (!device || typeof device !== 'object') {
+            return null;
+        }
+        const deviceId = typeof device.deviceId === 'string' ? device.deviceId : '';
+        if (deviceId && deviceId !== 'default') {
+            return deviceId;
+        }
+        const groupId = typeof device.groupId === 'string' ? device.groupId : '';
+        if (groupId) {
+            return groupId;
+        }
+        const label = typeof device.label === 'string' ? device.label : '';
+        if (label) {
+            return label;
+        }
+        return null;
     }
     /**
      * Mutes the microphone to stop sending audio to the server