@layercode/js-sdk 2.0.5 → 2.1.0

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

@@ -3235,6 +3235,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}"\`);
         }
@@ -3331,6 +3333,7 @@ registerProcessor('stream_processor', StreamProcessor);
       this.interruptedTrackIds = {};
       this.finishedPlayingCallback = finishedPlayingCallback;
       this.isPlaying = false;
+      this.amplitudeMonitorRaf = undefined;
     }
 
     /**
@@ -3416,14 +3419,22 @@ registerProcessor('stream_processor', StreamProcessor);
      * @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
@@ -3570,11 +3581,18 @@ registerProcessor('stream_processor', StreamProcessor);
       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;
@@ -3858,6 +3876,7 @@ registerProcessor('audio_processor', AudioProcessor);
         raw: new ArrayBuffer(0),
         mono: new ArrayBuffer(0),
       };
+      this.amplitudeMonitorRaf = void 0;
     }
 
     /**
@@ -4257,14 +4276,22 @@ registerProcessor('audio_processor', AudioProcessor);
      * @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
@@ -4397,6 +4424,7 @@ registerProcessor('audio_processor', AudioProcessor);
      * @returns {Promise<true>}
      */
     async quit() {
+      this.stopAmplitudeMonitoring();
       this.listenForDeviceChange(null);
       if (this.processor) {
         await this.end();
@@ -6300,6 +6328,8 @@ registerProcessor('audio_processor', AudioProcessor);
   }
 
   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';
@@ -6358,27 +6388,28 @@ registerProcessor('audio_processor', AudioProcessor);
        * @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),
@@ -6389,7 +6420,7 @@ registerProcessor('audio_processor', AudioProcessor);
           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;
@@ -6402,12 +6433,15 @@ registerProcessor('audio_processor', AudioProcessor);
           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;
@@ -6672,31 +6706,56 @@ registerProcessor('audio_processor', AudioProcessor);
        * @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,
@@ -6719,6 +6778,7 @@ registerProcessor('audio_processor', AudioProcessor);
               }
               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,
@@ -6748,8 +6808,12 @@ registerProcessor('audio_processor', AudioProcessor);
               };
               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);
@@ -6775,30 +6839,19 @@ registerProcessor('audio_processor', AudioProcessor);
           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
@@ -6896,43 +6949,106 @@ registerProcessor('audio_processor', AudioProcessor);
        * 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