@layercode/js-sdk 1.0.25 → 1.0.27

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

@@ -3483,6 +3483,8 @@ registerProcessor('audio_processor', AudioProcessor);
   }
 
   /* eslint-env browser */
+  // SDK version - updated when publishing
+  const SDK_VERSION = '1.0.27';
   /**
    * @class LayercodeClient
    * @classdesc Core client for Layercode audio pipeline that manages audio recording, WebSocket communication, and speech processing.
@@ -3493,6 +3495,7 @@ registerProcessor('audio_processor', AudioProcessor);
        * @param {Object} options - Configuration options
        */
       constructor(options) {
+          this.deviceId = null;
           this.options = {
               pipelineId: options.pipelineId,
               sessionId: options.sessionId || null,
@@ -3502,6 +3505,7 @@ registerProcessor('audio_processor', AudioProcessor);
               onConnect: options.onConnect || (() => { }),
               onDisconnect: options.onDisconnect || (() => { }),
               onError: options.onError || (() => { }),
+              onDeviceSwitched: options.onDeviceSwitched || (() => { }),
               onDataMessage: options.onDataMessage || (() => { }),
               onUserAmplitudeChange: options.onUserAmplitudeChange || (() => { }),
               onAgentAmplitudeChange: options.onAgentAmplitudeChange || (() => { }),
@@ -3525,198 +3529,99 @@ registerProcessor('audio_processor', AudioProcessor);
           this.pushToTalkEnabled = false;
           this.canInterrupt = false;
           this.userIsSpeaking = false;
-          this.endUserTurn = false;
           this.recorderStarted = false;
           this.readySent = false;
           this.currentTurnId = null;
           this.audioBuffer = [];
-          this.audioPauseTime = null;
+          this.vadConfig = null;
+          // this.audioPauseTime = null;
           // Bind event handlers
           this._handleWebSocketMessage = this._handleWebSocketMessage.bind(this);
           this._handleDataAvailable = this._handleDataAvailable.bind(this);
-      }
-      _setupAmplitudeBasedVAD() {
-          let isSpeakingByAmplitude = false;
-          let silenceFrames = 0;
-          const AMPLITUDE_THRESHOLD = 0.01; // Adjust based on testing
-          const SILENCE_FRAMES_THRESHOLD = 30; // ~600ms at 20ms chunks
-          // Monitor amplitude changes
-          this.wavRecorder.startAmplitudeMonitoring((amplitude) => {
-              const wasSpeaking = isSpeakingByAmplitude;
-              if (amplitude > AMPLITUDE_THRESHOLD) {
-                  silenceFrames = 0;
-                  if (!wasSpeaking) {
-                      // Speech started - pause audio if playing and track timing for interruption calculation
-                      if (this.canInterrupt && this.wavPlayer.isPlaying) {
-                          this.audioPauseTime = Date.now();
-                          this.wavPlayer.pause();
-                      }
-                      isSpeakingByAmplitude = true;
-                      this.userIsSpeaking = true;
-                      this.options.onUserIsSpeakingChange(true);
-                      this._wsSend({
-                          type: 'vad_events',
-                          event: 'vad_start',
-                      });
-                  }
-              }
-              else {
-                  silenceFrames++;
-                  if (wasSpeaking && silenceFrames >= SILENCE_FRAMES_THRESHOLD) {
-                      // Speech ended
-                      isSpeakingByAmplitude = false;
-                      this.userIsSpeaking = false;
-                      this.options.onUserIsSpeakingChange(false);
-                      this._wsSend({
-                          type: 'vad_events',
-                          event: 'vad_end',
-                      });
-                  }
-              }
-          });
+          this._setupDeviceChangeListener();
       }
       _initializeVAD() {
-          console.log('initializing VAD', { pushToTalkEnabled: this.pushToTalkEnabled, canInterrupt: this.canInterrupt });
+          var _a;
+          console.log('initializing VAD', { pushToTalkEnabled: this.pushToTalkEnabled, canInterrupt: this.canInterrupt, vadConfig: this.vadConfig });
           // If we're in push to talk mode, we don't need to use the VAD model
           if (this.pushToTalkEnabled) {
               return;
           }
-          const timeout = setTimeout(() => {
-              console.log('silero vad model timeout');
-              console.warn('VAD model failed to load - falling back to amplitude-based detection');
+          // Check if VAD is disabled
+          if (((_a = this.vadConfig) === null || _a === void 0 ? void 0 : _a.enabled) === false) {
+              console.log('VAD is disabled by backend configuration');
+              return;
+          }
+          // Build VAD configuration object, only including keys that are defined
+          const vadOptions = {
+              stream: this.wavRecorder.getStream() || undefined,
+              onSpeechStart: () => {
+                  console.log('onSpeechStart: sending vad_start');
+                  this.userIsSpeaking = true;
+                  this.options.onUserIsSpeakingChange(true);
+                  this._wsSend({
+                      type: 'vad_events',
+                      event: 'vad_start',
+                  });
+              },
+              onSpeechEnd: () => {
+                  console.log('onSpeechEnd: sending vad_end');
+                  this.userIsSpeaking = false;
+                  this.options.onUserIsSpeakingChange(false);
+                  this.audioBuffer = []; // Clear buffer on speech end
+                  this._wsSend({
+                      type: 'vad_events',
+                      event: 'vad_end',
+                  });
+              },
+          };
+          // Apply VAD configuration from backend if available
+          if (this.vadConfig) {
+              // Only add keys that are explicitly defined (not undefined)
+              if (this.vadConfig.model !== undefined)
+                  vadOptions.model = this.vadConfig.model;
+              if (this.vadConfig.positive_speech_threshold !== undefined)
+                  vadOptions.positiveSpeechThreshold = this.vadConfig.positive_speech_threshold;
+              if (this.vadConfig.negative_speech_threshold !== undefined)
+                  vadOptions.negativeSpeechThreshold = this.vadConfig.negative_speech_threshold;
+              if (this.vadConfig.redemption_frames !== undefined)
+                  vadOptions.redemptionFrames = this.vadConfig.redemption_frames;
+              if (this.vadConfig.min_speech_frames !== undefined)
+                  vadOptions.minSpeechFrames = this.vadConfig.min_speech_frames;
+              if (this.vadConfig.pre_speech_pad_frames !== undefined)
+                  vadOptions.preSpeechPadFrames = this.vadConfig.pre_speech_pad_frames;
+              if (this.vadConfig.frame_samples !== undefined)
+                  vadOptions.frameSamples = this.vadConfig.frame_samples;
+          }
+          else {
+              // Default values if no config from backend
+              vadOptions.model = 'v5';
+              vadOptions.positiveSpeechThreshold = 0.15;
+              vadOptions.negativeSpeechThreshold = 0.05;
+              vadOptions.redemptionFrames = 4;
+              vadOptions.minSpeechFrames = 2;
+              vadOptions.preSpeechPadFrames = 0;
+              vadOptions.frameSamples = 512; // Required for v5
+          }
+          console.log('Creating VAD with options:', vadOptions);
+          dist.MicVAD.new(vadOptions)
+              .then((vad) => {
+              this.vad = vad;
+              this.vad.start();
+              console.log('VAD started successfully');
+          })
+              .catch((error) => {
+              console.warn('Error initializing VAD:', error);
               // Send a message to server indicating VAD failure
               this._wsSend({
                   type: 'vad_events',
                   event: 'vad_model_failed',
               });
-              // In automatic mode without VAD, allow the bot to speak initially
-              this.userIsSpeaking = false;
-              this.options.onUserIsSpeakingChange(false);
-              // Set up amplitude-based fallback detection
-              this._setupAmplitudeBasedVAD();
-          }, 2000);
-          if (!this.canInterrupt) {
-              dist.MicVAD.new({
-                  stream: this.wavRecorder.getStream() || undefined,
-                  model: 'v5',
-                  positiveSpeechThreshold: 0.7,
-                  negativeSpeechThreshold: 0.55,
-                  redemptionFrames: 25, // Number of frames of silence before onVADMisfire or onSpeechEnd is called. Effectively a delay before restarting.
-                  minSpeechFrames: 0,
-                  preSpeechPadFrames: 0,
-                  onSpeechStart: () => {
-                      this.userIsSpeaking = true;
-                      this.options.onUserIsSpeakingChange(true);
-                      console.log('onSpeechStart: sending vad_start');
-                      this._wsSend({
-                          type: 'vad_events',
-                          event: 'vad_start',
-                      });
-                  },
-                  onSpeechEnd: () => {
-                      console.log('onSpeechEnd: sending vad_end');
-                      this.endUserTurn = true; // Set flag to indicate that the user turn has ended
-                      this.audioBuffer = []; // Clear buffer on speech end
-                      this.userIsSpeaking = false;
-                      this.options.onUserIsSpeakingChange(false);
-                      console.log('onSpeechEnd: State after update - endUserTurn:', this.endUserTurn, 'userIsSpeaking:', this.userIsSpeaking);
-                      // Send vad_end immediately instead of waiting for next audio chunk
-                      this._wsSend({
-                          type: 'vad_events',
-                          event: 'vad_end',
-                      });
-                      this.endUserTurn = false; // Reset the flag after sending vad_end
-                  },
-              })
-                  .then((vad) => {
-                  clearTimeout(timeout);
-                  this.vad = vad;
-                  this.vad.start();
-                  console.log('VAD started');
-              })
-                  .catch((error) => {
-                  console.error('Error initializing VAD:', error);
-              });
-          }
-          else {
-              dist.MicVAD.new({
-                  stream: this.wavRecorder.getStream() || undefined,
-                  model: 'v5',
-                  // baseAssetPath: '/', // Use if bundling model locally
-                  // onnxWASMBasePath: '/', // Use if bundling model locally
-                  positiveSpeechThreshold: 0.7,
-                  negativeSpeechThreshold: 0.55,
-                  redemptionFrames: 25, // Number of frames of silence before onVADMisfire or onSpeechEnd is called. Effectively a delay before restarting.
-                  minSpeechFrames: 25,
-                  preSpeechPadFrames: 0,
-                  onSpeechStart: () => {
-                      // Only pause agent audio if it's currently playing
-                      if (this.wavPlayer.isPlaying) {
-                          console.log('onSpeechStart: WavPlayer is playing, pausing it.');
-                          this.audioPauseTime = Date.now(); // Track when we paused
-                          this.wavPlayer.pause();
-                      }
-                      else {
-                          console.log('onSpeechStart: WavPlayer is not playing, VAD will not pause.');
-                      }
-                      console.log('onSpeechStart: sending vad_start');
-                      this._wsSend({
-                          type: 'vad_events',
-                          event: 'vad_start',
-                      });
-                      this.userIsSpeaking = true;
-                      this.options.onUserIsSpeakingChange(true);
-                      this.endUserTurn = false; // Reset endUserTurn when speech starts
-                      console.log('onSpeechStart: State after update - endUserTurn:', this.endUserTurn, 'userIsSpeaking:', this.userIsSpeaking);
-                  },
-                  onVADMisfire: () => {
-                      // If the speech detected was for less than minSpeechFrames, this is called instead of onSpeechEnd, and we should resume the assistant audio as it was a false interruption. We include a configurable delay so the assistant isn't too quick to start speaking again.
-                      this.userIsSpeaking = false;
-                      this.audioBuffer = []; // Clear buffer on misfire
-                      this.options.onUserIsSpeakingChange(false);
-                      // Add the missing delay before resuming to prevent race conditions
-                      setTimeout(() => {
-                          if (!this.wavPlayer.isPlaying) {
-                              console.log('onVADMisfire: Resuming after delay');
-                              this.audioPauseTime = null; // Clear pause time since we're resuming
-                              this.wavPlayer.play();
-                          }
-                          else {
-                              console.log('onVADMisfire: Not resuming - either no pause or user speaking again');
-                              this.endUserTurn = true;
-                          }
-                      }, this.options.vadResumeDelay);
-                  },
-                  onSpeechEnd: () => {
-                      console.log('onSpeechEnd: sending vad_end');
-                      this.endUserTurn = true; // Set flag to indicate that the user turn has ended
-                      this.audioBuffer = []; // Clear buffer on speech end
-                      this.userIsSpeaking = false;
-                      this.options.onUserIsSpeakingChange(false);
-                      console.log('onSpeechEnd: State after update - endUserTurn:', this.endUserTurn, 'userIsSpeaking:', this.userIsSpeaking);
-                      // Send vad_end immediately instead of waiting for next audio chunk
-                      this._wsSend({
-                          type: 'vad_events',
-                          event: 'vad_end',
-                      });
-                      this.endUserTurn = false; // Reset the flag after sending vad_end
-                  },
-              })
-                  .then((vad) => {
-                  clearTimeout(timeout);
-                  this.vad = vad;
-                  this.vad.start();
-                  console.log('VAD started');
-              })
-                  .catch((error) => {
-                  console.error('Error initializing VAD:', error);
-              });
-          }
+          });
       }
       /**
        * Updates the connection status and triggers the callback
        * @param {string} status - New status value
-       * @private
        */
       _setStatus(status) {
           this.status = status;
@@ -3724,7 +3629,6 @@ registerProcessor('audio_processor', AudioProcessor);
       }
       /**
        * Handles when agent audio finishes playing
-       * @private
        */
       _clientResponseAudioReplayFinished() {
           console.log('clientResponseAudioReplayFinished');
@@ -3737,17 +3641,6 @@ registerProcessor('audio_processor', AudioProcessor);
           const offsetData = await this.wavPlayer.interrupt();
           if (offsetData && this.currentTurnId) {
               let offsetMs = offsetData.currentTime * 1000;
-              // Calculate accurate offset by subtracting pause time if audio was paused for VAD
-              if (this.audioPauseTime) {
-                  const pauseDurationMs = Date.now() - this.audioPauseTime;
-                  const adjustedOffsetMs = Math.max(0, offsetMs - pauseDurationMs);
-                  console.log(`Interruption detected: Raw offset ${offsetMs}ms, pause duration ${pauseDurationMs}ms, adjusted offset ${adjustedOffsetMs}ms for turn ${this.currentTurnId}`);
-                  offsetMs = adjustedOffsetMs;
-                  this.audioPauseTime = null; // Clear the pause time
-              }
-              else {
-                  console.log(`Interruption detected: ${offsetMs}ms offset for turn ${this.currentTurnId} (no pause adjustment needed)`);
-              }
               // Send interruption event with accurate playback offset in milliseconds
               this._wsSend({
                   type: 'trigger.response.audio.interrupted',
@@ -3781,7 +3674,6 @@ registerProcessor('audio_processor', AudioProcessor);
       /**
        * Handles incoming WebSocket messages
        * @param {MessageEvent} event - The WebSocket message event
-       * @private
        */
       async _handleWebSocketMessage(event) {
           try {
@@ -3796,12 +3688,10 @@ registerProcessor('audio_processor', AudioProcessor);
                       console.log(message);
                       if (message.role === 'assistant') {
                           // Start tracking new assistant turn
-                          // Note: Don't reset currentTurnId here - let response.audio set it
-                          // This prevents race conditions where text arrives before audio
                           console.log('Assistant turn started, will track new turn ID from audio/text');
                       }
-                      else if (message.role === 'user' && !this.pushToTalkEnabled && this.canInterrupt) {
-                          // Interrupt any playing assistant audio if this is a turn trigged by the server (and not push to talk, which will have already called interrupt)
+                      else if (message.role === 'user' && !this.pushToTalkEnabled) {
+                          // Interrupt any playing assistant audio if this is a turn triggered by the server (and not push to talk, which will have already called interrupt)
                           console.log('interrupting assistant audio, as user turn has started and pushToTalkEnabled is false');
                           await this._clientInterruptAssistantReplay();
                       }
@@ -3823,7 +3713,6 @@ registerProcessor('audio_processor', AudioProcessor);
                           this.currentTurnId = message.turn_id;
                           console.log(`Setting current turn ID to: ${message.turn_id} from text message`);
                       }
-                      // Note: We no longer track text content in the client - the pipeline handles interruption estimation
                       break;
                   }
                   case 'response.data':
@@ -3831,7 +3720,7 @@ registerProcessor('audio_processor', AudioProcessor);
                       this.options.onDataMessage(message);
                       break;
                   default:
-                      console.error('Unknown message type received:', message);
+                      console.warn('Unknown message type received:', message);
                       break;
               }
           }
@@ -3843,15 +3732,28 @@ registerProcessor('audio_processor', AudioProcessor);
       /**
        * Handles available client browser microphone audio data and sends it over the WebSocket
        * @param {ArrayBuffer} data - The audio data buffer
-       * @private
        */
       _handleDataAvailable(data) {
+          var _a, _b, _c;
           try {
               const base64 = arrayBufferToBase64(data.mono);
-              const sendAudio = this.pushToTalkEnabled ? this.pushToTalkActive : this.userIsSpeaking;
+              // Determine if we should gate audio based on VAD configuration
+              const shouldGateAudio = ((_a = this.vadConfig) === null || _a === void 0 ? void 0 : _a.gate_audio) !== false; // Default to true if not specified
+              const bufferFrames = (_c = (_b = this.vadConfig) === null || _b === void 0 ? void 0 : _b.buffer_frames) !== null && _c !== void 0 ? _c : 10; // Default to 10 if not specified
+              let sendAudio;
+              if (this.pushToTalkEnabled) {
+                  sendAudio = this.pushToTalkActive;
+              }
+              else if (shouldGateAudio) {
+                  sendAudio = this.userIsSpeaking;
+              }
+              else {
+                  // If gate_audio is false, always send audio
+                  sendAudio = true;
+              }
               if (sendAudio) {
-                  // If we have buffered audio, send it first
-                  if (this.audioBuffer.length > 0) {
+                  // If we have buffered audio and we're gating, send it first
+                  if (shouldGateAudio && this.audioBuffer.length > 0) {
                       console.log(`Sending ${this.audioBuffer.length} buffered audio chunks`);
                       for (const bufferedAudio of this.audioBuffer) {
                           this._wsSend({
@@ -3870,8 +3772,8 @@ registerProcessor('audio_processor', AudioProcessor);
               else {
                   // Buffer audio when not sending (to catch audio just before VAD triggers)
                   this.audioBuffer.push(base64);
-                  // Keep buffer size reasonable (e.g., last 10 chunks ≈ 200ms at 20ms chunks)
-                  if (this.audioBuffer.length > 10) {
+                  // Keep buffer size based on configuration
+                  if (this.audioBuffer.length > bufferFrames) {
                       this.audioBuffer.shift(); // Remove oldest chunk
                   }
               }
@@ -3903,7 +3805,6 @@ registerProcessor('audio_processor', AudioProcessor);
        * @param {WavRecorder | WavStreamPlayer} source - The audio source (recorder or player).
        * @param {(amplitude: number) => void} callback - The callback function to invoke on amplitude change.
        * @param {(amplitude: number) => void} updateInternalState - Function to update the internal amplitude state.
-       * @private
        */
       _setupAmplitudeMonitoring(source, callback, updateInternalState) {
           // Set up amplitude monitoring only if a callback is provided
@@ -3935,6 +3836,7 @@ registerProcessor('audio_processor', AudioProcessor);
               let authorizeSessionRequestBody = {
                   pipeline_id: this.options.pipelineId,
                   metadata: this.options.metadata,
+                  sdk_version: SDK_VERSION,
               };
               // If we're reconnecting to a previous session, we need to include the session_id in the request. Otherwise we don't send session_id, and a new session will be created and the session_id will be returned in the response.
               if (this.options.sessionId) {
@@ -3958,6 +3860,8 @@ registerProcessor('audio_processor', AudioProcessor);
             })}`);
               const config = authorizeSessionResponseBody.config;
               console.log('config', config);
+              // Store VAD configuration
+              this.vadConfig = config.vad || null;
               if (config.transcription.trigger === 'push_to_talk') {
                   this.pushToTalkEnabled = true;
               }
@@ -3968,7 +3872,6 @@ registerProcessor('audio_processor', AudioProcessor);
               else {
                   throw new Error(`Unknown trigger: ${config.transcription.trigger}`);
               }
-              this._initializeVAD();
               // Bind the websocket message callbacks
               this.ws.onmessage = this._handleWebSocketMessage;
               this.ws.onopen = () => {
@@ -3988,18 +3891,13 @@ registerProcessor('audio_processor', AudioProcessor);
                   this._setStatus('error');
                   this.options.onError(new Error('WebSocket connection error'));
               };
-              // Initialize microphone audio capture
-              await this.wavRecorder.begin();
-              await this.wavRecorder.record(this._handleDataAvailable, 1638);
-              // Set up microphone amplitude monitoring
-              this._setupAmplitudeMonitoring(this.wavRecorder, this.options.onUserAmplitudeChange, (amp) => (this.userAudioAmplitude = amp));
               // Initialize audio player
               await this.wavPlayer.connect();
               // Set up audio player amplitude monitoring
               this._setupAmplitudeMonitoring(this.wavPlayer, this.options.onAgentAmplitudeChange, (amp) => (this.agentAudioAmplitude = amp));
-              // Mark recorder as started and attempt to notify server
-              this.recorderStarted = true;
-              this._sendReadyIfNeeded();
+              // wavRecorder will be started from the onDeviceSwitched callback,
+              // which is called when the device is first initialized and also when the device is switched
+              // this is to ensure that the device is initialized before the recorder is started
           }
           catch (error) {
               console.error('Error connecting to Layercode pipeline:', error);
@@ -4019,6 +3917,7 @@ registerProcessor('audio_processor', AudioProcessor);
               this.vad.destroy();
               this.vad = null;
           }
+          this.wavRecorder.listenForDeviceChange(null);
           this.wavRecorder.quit();
           this.wavPlayer.disconnect();
           // Reset turn tracking
@@ -4042,19 +3941,101 @@ registerProcessor('audio_processor', AudioProcessor);
        * @param {string} deviceId - The deviceId of the new microphone
        */
       async setInputDevice(deviceId) {
-          if (this.wavRecorder) {
+          var _a;
+          try {
+              this.deviceId = deviceId;
+              // Restart recording with the new device
+              await this._restartAudioRecording();
+              // Reinitialize VAD with the new audio stream if VAD is enabled
+              const shouldUseVAD = !this.pushToTalkEnabled && ((_a = this.vadConfig) === null || _a === void 0 ? void 0 : _a.enabled) !== false;
+              if (shouldUseVAD) {
+                  console.log('Reinitializing VAD with new audio stream');
+                  const newStream = this.wavRecorder.getStream();
+                  await this._reinitializeVAD(newStream);
+              }
+              console.log(`Successfully switched to input device: ${deviceId}`);
+          }
+          catch (error) {
+              console.error(`Failed to switch to input device ${deviceId}:`, error);
+              throw new Error(`Failed to switch to input device: ${error instanceof Error ? error.message : String(error)}`);
+          }
+      }
+      /**
+       * Restarts audio recording after a device switch to ensure audio is captured from the new device
+       */
+      async _restartAudioRecording() {
+          try {
+              console.log('Restarting audio recording after device switch...');
               try {
                   await this.wavRecorder.end();
               }
-              catch (e) { }
-              try {
-                  await this.wavRecorder.quit();
+              catch (_a) {
+                  // Ignore cleanup errors
               }
-              catch (e) { }
+              // Start with new device
+              await this.wavRecorder.begin(this.deviceId || undefined);
+              await this.wavRecorder.record(this._handleDataAvailable, 1638);
+              // Re-setup amplitude monitoring with the new stream
+              this._setupAmplitudeMonitoring(this.wavRecorder, this.options.onUserAmplitudeChange, (amp) => (this.userAudioAmplitude = amp));
+              console.log('Audio recording restart completed successfully');
+          }
+          catch (error) {
+              console.error('Error restarting audio recording after device switch:', error);
+              this.options.onError(error instanceof Error ? error : new Error(String(error)));
           }
-          await this.wavRecorder.begin(deviceId);
-          await this.wavRecorder.record(this._handleDataAvailable, 1638);
-          this._setupAmplitudeMonitoring(this.wavRecorder, this.options.onUserAmplitudeChange, (amp) => (this.userAudioAmplitude = amp));
+      }
+      /**
+       * Reinitializes VAD with a new stream (used after device switching)
+       */
+      async _reinitializeVAD(stream) {
+          // Clean up existing VAD
+          if (this.vad) {
+              this.vad.pause();
+              this.vad.destroy();
+              this.vad = null;
+          }
+          // Reinitialize with new stream
+          if (stream) {
+              this._initializeVAD();
+          }
+      }
+      /**
+       * Sets up the device change event listener
+       */
+      _setupDeviceChangeListener() {
+          this.wavRecorder.listenForDeviceChange(async (devices) => {
+              try {
+                  const currentDeviceExists = devices.some((device) => device.deviceId === this.deviceId);
+                  if (!currentDeviceExists) {
+                      console.log('Current device disconnected, switching to next available device');
+                      try {
+                          const nextDevice = devices.find((d) => d.default);
+                          if (nextDevice) {
+                              await this.setInputDevice(nextDevice.deviceId);
+                              // Mark recorder as started and attempt to notify server
+                              if (!this.recorderStarted) {
+                                  this.recorderStarted = true;
+                                  this._sendReadyIfNeeded();
+                              }
+                              // Notify about device switch
+                              if (this.options.onDeviceSwitched) {
+                                  this.options.onDeviceSwitched(nextDevice.deviceId);
+                              }
+                          }
+                          else {
+                              console.warn('No alternative audio device found');
+                          }
+                      }
+                      catch (error) {
+                          console.error('Error switching to next device:', error);
+                          throw error;
+                      }
+                  }
+              }
+              catch (error) {
+                  this.options.onError(error instanceof Error ? error : new Error(String(error)));
+              }
+          });
       }
   }