@layercode/js-sdk 2.0.1 → 2.0.3

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

@@ -3484,7 +3484,7 @@ registerProcessor('audio_processor', AudioProcessor);
 
   /* eslint-env browser */
   // SDK version - updated when publishing
-  const SDK_VERSION = '2.0.0';
+  const SDK_VERSION = '2.0.2';
   /**
    * @class LayercodeClient
    * @classdesc Core client for Layercode audio agent that manages audio recording, WebSocket communication, and speech processing.
@@ -3507,13 +3507,15 @@ registerProcessor('audio_processor', AudioProcessor);
               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 || (() => { }),
           };
-          this.AMPLITUDE_MONITORING_SAMPLE_RATE = 10;
-          this._websocketUrl = 'wss://api.layercode.com/v1/agents/websocket';
+          this.AMPLITUDE_MONITORING_SAMPLE_RATE = 2;
+          this._websocketUrl = 'wss://api.layercode.com/v1/agents/web/websocket';
           this.wavRecorder = new WavRecorder({ sampleRate: 8000 }); // TODO should be set my fetched agent config
           this.wavPlayer = new WavStreamPlayer({
               finishedPlayingCallback: this._clientResponseAudioReplayFinished.bind(this),
@@ -3534,6 +3536,7 @@ registerProcessor('audio_processor', AudioProcessor);
           this.currentTurnId = null;
           this.audioBuffer = [];
           this.vadConfig = null;
+          this.isMuted = false;
           // this.audioPauseTime = null;
           // Bind event handlers
           this._handleWebSocketMessage = this._handleWebSocketMessage.bind(this);
@@ -3556,16 +3559,20 @@ registerProcessor('audio_processor', AudioProcessor);
           const vadOptions = {
               stream: this.wavRecorder.getStream() || undefined,
               onSpeechStart: () => {
-                  console.log('onSpeechStart: sending vad_start');
+                  console.debug('onSpeechStart: sending vad_start');
                   this.userIsSpeaking = true;
                   this.options.onUserIsSpeakingChange(true);
                   this._wsSend({
                       type: 'vad_events',
                       event: 'vad_start',
                   });
+                  this.options.onMessage({
+                      type: 'vad_events',
+                      event: 'vad_start',
+                  });
               },
               onSpeechEnd: () => {
-                  console.log('onSpeechEnd: sending vad_end');
+                  console.debug('onSpeechEnd: sending vad_end');
                   this.userIsSpeaking = false;
                   this.options.onUserIsSpeakingChange(false);
                   this.audioBuffer = []; // Clear buffer on speech end
@@ -3573,6 +3580,10 @@ registerProcessor('audio_processor', AudioProcessor);
                       type: 'vad_events',
                       event: 'vad_end',
                   });
+                  this.options.onMessage({
+                      type: 'vad_events',
+                      event: 'vad_end',
+                  });
               },
           };
           // Apply VAD configuration from backend if available
@@ -3631,32 +3642,14 @@ registerProcessor('audio_processor', AudioProcessor);
        * Handles when agent audio finishes playing
        */
       _clientResponseAudioReplayFinished() {
-          console.log('clientResponseAudioReplayFinished');
+          console.debug('clientResponseAudioReplayFinished');
           this._wsSend({
               type: 'trigger.response.audio.replay_finished',
               reason: 'completed',
           });
       }
       async _clientInterruptAssistantReplay() {
-          const offsetData = await this.wavPlayer.interrupt();
-          if (offsetData && this.currentTurnId) {
-              let offsetMs = offsetData.currentTime * 1000;
-              // Send interruption event with accurate playback offset in milliseconds
-              this._wsSend({
-                  type: 'trigger.response.audio.interrupted',
-                  playback_offset: offsetMs,
-                  interruption_context: {
-                      turn_id: this.currentTurnId,
-                      playback_offset_ms: offsetMs,
-                  },
-              });
-          }
-          else {
-              console.warn('Interruption requested but missing required data:', {
-                  hasOffsetData: !!offsetData,
-                  hasTurnId: !!this.currentTurnId,
-              });
-          }
+          await this.wavPlayer.interrupt();
       }
       async triggerUserTurnStarted() {
           if (!this.pushToTalkActive) {
@@ -3679,49 +3672,51 @@ registerProcessor('audio_processor', AudioProcessor);
           try {
               const message = JSON.parse(event.data);
               if (message.type !== 'response.audio') {
-                  console.log('received ws msg:', message);
+                  console.debug('msg:', message);
               }
               switch (message.type) {
                   case 'turn.start':
                       // Sent from the server to this client when a new user turn is detected
-                      console.log('received turn.start from server');
-                      console.log(message);
                       if (message.role === 'assistant') {
                           // Start tracking new assistant turn
-                          console.log('Assistant turn started, will track new turn ID from audio/text');
+                          console.debug('Assistant turn started, will track new turn ID from audio/text');
                       }
                       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');
+                          console.debug('interrupting assistant audio, as user turn has started and pushToTalkEnabled is false');
                           await this._clientInterruptAssistantReplay();
                       }
+                      this.options.onMessage(message);
                       break;
                   case 'response.audio':
                       const audioBuffer = base64ToArrayBuffer(message.content);
                       this.wavPlayer.add16BitPCM(audioBuffer, message.turn_id);
+                      // TODO: once we've added turn_id to the turn.start msgs sent from teh server, we should move this currentTurnId switching logic to the turn.start msg case. We can then remove the currentTurnId setting logic from the response.audio and response.text cases.
                       // Set current turn ID from first audio message, or update if different turn
                       if (!this.currentTurnId || this.currentTurnId !== message.turn_id) {
-                          console.log(`Setting current turn ID to: ${message.turn_id} (was: ${this.currentTurnId})`);
+                          console.debug(`Setting current turn ID to: ${message.turn_id} (was: ${this.currentTurnId})`);
                           this.currentTurnId = message.turn_id;
                           // Clean up interrupted tracks, keeping only the current turn
                           this.wavPlayer.clearInterruptedTracks(this.currentTurnId ? [this.currentTurnId] : []);
                       }
                       break;
-                  case 'response.text': {
+                  case 'response.text':
                       // Set turn ID from first text message if not set
                       if (!this.currentTurnId) {
                           this.currentTurnId = message.turn_id;
-                          console.log(`Setting current turn ID to: ${message.turn_id} from text message`);
+                          console.debug(`Setting current turn ID to: ${message.turn_id} from text message`);
                       }
+                      this.options.onMessage(message);
                       break;
-                  }
                   case 'response.data':
-                      console.log('received response.data', message);
                       this.options.onDataMessage(message);
                       break;
+                  case 'user.transcript':
+                  case 'user.transcript.delta':
+                      this.options.onMessage(message);
+                      break;
                   default:
                       console.warn('Unknown message type received:', message);
-                      break;
               }
           }
           catch (error) {
@@ -3737,6 +3732,10 @@ registerProcessor('audio_processor', AudioProcessor);
           var _a, _b, _c;
           try {
               const base64 = arrayBufferToBase64(data.mono);
+              // Don't send audio if muted
+              if (this.isMuted) {
+                  return;
+              }
               // 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
@@ -3754,7 +3753,7 @@ registerProcessor('audio_processor', AudioProcessor);
               if (sendAudio) {
                   // 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`);
+                      console.debug(`Sending ${this.audioBuffer.length} buffered audio chunks`);
                       for (const bufferedAudio of this.audioBuffer) {
                           this._wsSend({
                               type: 'client.audio',
@@ -3786,7 +3785,7 @@ registerProcessor('audio_processor', AudioProcessor);
       _wsSend(message) {
           var _a;
           if (message.type !== 'client.audio') {
-              console.log('sent ws msg:', message);
+              console.debug('sent_msg:', message);
           }
           const messageString = JSON.stringify(message);
           if (((_a = this.ws) === null || _a === void 0 ? void 0 : _a.readyState) === WebSocket.OPEN) {
@@ -3859,7 +3858,7 @@ registerProcessor('audio_processor', AudioProcessor);
                 client_session_key: authorizeSessionResponseBody.client_session_key,
             })}`);
               const config = authorizeSessionResponseBody.config;
-              console.log('config', config);
+              console.log('AgentConfig', config);
               // Store VAD configuration
               this.vadConfig = config.vad || null;
               if (config.transcription.trigger === 'push_to_talk') {
@@ -3908,7 +3907,7 @@ registerProcessor('audio_processor', AudioProcessor);
       }
       _resetTurnTracking() {
           this.currentTurnId = null;
-          console.log('Reset turn tracking state');
+          console.debug('Reset turn tracking state');
       }
       async disconnect() {
           // Clean up VAD if it exists
@@ -3949,11 +3948,11 @@ registerProcessor('audio_processor', AudioProcessor);
               // 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');
+                  console.debug('Reinitializing VAD with new audio stream');
                   const newStream = this.wavRecorder.getStream();
                   await this._reinitializeVAD(newStream);
               }
-              console.log(`Successfully switched to input device: ${deviceId}`);
+              console.debug(`Successfully switched to input device: ${deviceId}`);
           }
           catch (error) {
               console.error(`Failed to switch to input device ${deviceId}:`, error);
@@ -3965,7 +3964,7 @@ registerProcessor('audio_processor', AudioProcessor);
        */
       async _restartAudioRecording() {
           try {
-              console.log('Restarting audio recording after device switch...');
+              console.debug('Restarting audio recording after device switch...');
               try {
                   await this.wavRecorder.end();
               }
@@ -3977,7 +3976,7 @@ registerProcessor('audio_processor', AudioProcessor);
               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');
+              console.debug('Audio recording restart completed successfully');
           }
           catch (error) {
               console.error('Error restarting audio recording after device switch:', error);
@@ -4007,7 +4006,7 @@ registerProcessor('audio_processor', AudioProcessor);
               try {
                   const currentDeviceExists = devices.some((device) => device.deviceId === this.deviceId);
                   if (!currentDeviceExists) {
-                      console.log('Current device disconnected, switching to next available device');
+                      console.debug('Current device disconnected, switching to next available device');
                       try {
                           const nextDevice = devices.find((d) => d.default);
                           if (nextDevice) {
@@ -4037,6 +4036,27 @@ registerProcessor('audio_processor', AudioProcessor);
               }
           });
       }
+      /**
+       * Mutes the microphone to stop sending audio to the server
+       * The connection and recording remain active for quick unmute
+       */
+      mute() {
+          if (!this.isMuted) {
+              this.isMuted = true;
+              console.log('Microphone muted');
+              this.options.onMuteStateChange(true);
+          }
+      }
+      /**
+       * Unmutes the microphone to resume sending audio to the server
+       */
+      unmute() {
+          if (this.isMuted) {
+              this.isMuted = false;
+              console.log('Microphone unmuted');
+              this.options.onMuteStateChange(false);
+          }
+      }
   }
 
   return LayercodeClient;