@layercode/js-sdk 1.0.5 → 1.0.7

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

@@ -1516,8 +1516,6 @@ registerProcessor('audio_processor', AudioProcessor);
    * @classdesc Core client for Layercode audio pipeline that manages audio recording, WebSocket communication, and speech processing.
    */
   class LayercodeClient {
-      // private currentTurnId: string | null = null;
-      // private lastDeltaIdPlayed: string | null = null;
       /**
        * Creates an instance of LayercodeClient.
        * @param {Object} options - Configuration options
@@ -1547,12 +1545,8 @@ registerProcessor('audio_processor', AudioProcessor);
           this.status = 'disconnected';
           this.userAudioAmplitude = 0;
           this.agentAudioAmplitude = 0;
-          this.assistantIsSpeaking = false;
-          this.assistantHasBeenInterrupted = false;
           this.sessionId = options.sessionId || null;
           this.pushToTalkActive = false;
-          // this.currentTurnId = null; // TODO implement
-          // this.lastDeltaIdPlayed = null; // TODO implement
           // Bind event handlers
           this._handleWebSocketMessage = this._handleWebSocketMessage.bind(this);
           this._handleDataAvailable = this._handleDataAvailable.bind(this);
@@ -1571,48 +1565,21 @@ registerProcessor('audio_processor', AudioProcessor);
        * @private
        */
       _clientResponseAudioReplayFinished() {
-          this.assistantIsSpeaking = false;
-          this._wsSend({
-              type: 'trigger.response.audio.replay_finished',
-              reason: 'completed',
-              // last_delta_id_played: this.lastDeltaIdPlayed, // TODO implement
-              // turn_id: this.currentTurnId, // TODO implement
-          });
-      }
-      async _setupWavPlayer() {
-          this.wavPlayer = new WavStreamPlayer({
-              finishedPlayingCallback: this._clientResponseAudioReplayFinished.bind(this),
-              sampleRate: 16000, // TODO should be set my fetched pipeline config
-          });
-          await this.wavPlayer.connect();
-          // Set up amplitude monitoring only if callbacks are provided
-          if (this.options.onAgentAmplitudeChange !== (() => { })) {
-              let agentUpdateCounter = 0;
-              this.wavPlayer.startAmplitudeMonitoring((amplitude) => {
-                  if (agentUpdateCounter == this.AMPLITUDE_MONITORING_SAMPLE_RATE) {
-                      this.agentAudioAmplitude = amplitude;
-                      this.options.onAgentAmplitudeChange(amplitude);
-                      agentUpdateCounter = 0; // Reset after each sample
-                  }
-                  agentUpdateCounter++;
-              });
-          }
+          console.log('clientResponseAudioReplayFinished');
+          // NOTE: Not currently used in voice pipelines
+          // this._wsSend({
+          //   type: 'trigger.response.audio.replay_finished',
+          //   reason: 'completed',
+          // });
       }
       async _clientInterruptAssistantReplay() {
-          if (this.assistantIsSpeaking) {
-              await this.wavPlayer.interrupt();
-              console.log('interrupting assistant replay');
-              console.log('setting assistantIsSpeaking to false');
-              console.log('setting assistantHasBeenInterrupted to true');
-              this.assistantIsSpeaking = false;
-              this.assistantHasBeenInterrupted = true;
-              this._wsSend({
-                  type: 'trigger.response.audio.replay_finished',
-                  reason: 'interrupted',
-                  // last_delta_id_played: this.lastDeltaIdPlayed, // TODO implement
-                  // turn_id: this.currentTurnId, // TODO implement
-              });
-          }
+          await this.wavPlayer.interrupt();
+          // TODO: Use in voice pipeline to know how much of the audio has been played and how much to truncate transcript
+          // this._wsSend({
+          //   type: 'trigger.response.audio.replay_finished',
+          //   reason: 'interrupted',
+          //   delta_id: 'TODO'
+          // });
       }
       async triggerUserTurnStarted() {
           if (!this.pushToTalkActive) {
@@ -1640,37 +1607,23 @@ registerProcessor('audio_processor', AudioProcessor);
               }
               switch (message.type) {
                   case 'turn.start':
-                      // Sent from the server to this client when a new user turn is detected. The client should interrupt any playing assistant audio and send a "trigger.response.audio.replay_finished" event to the server.
-                      if (message.role === 'user') {
-                          // Interrupt any playing assistant audio
-                          // await this._clientInterruptAssistantReplay(); // TODO work whether to call interrupt or not here
+                      // Sent from the server to this client when a new user turn is detected
+                      console.log('received turn.start from server');
+                      if (message.role === 'user' && !this.pushToTalkActive) {
+                          // 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)
+                          console.log('interrupting assistant audio, as user turn has started and pushToTalkActive is false');
+                          await this._clientInterruptAssistantReplay();
                       }
                       break;
                   case 'response.audio':
-                      // console.log("received response.audio");
-                      if (!this.assistantHasBeenInterrupted) {
-                          // If the assistant has been interrupted, ignore the rest of the audio chunks for this response (turn)
-                          // TODO: scope audio chunks we ignore based on the turn_id
-                          if (!this.assistantIsSpeaking) {
-                              // If we have switch from assistant not speaking to now speaking, this is the start of the assistant's response
-                              this.assistantIsSpeaking = true;
-                              console.log('assistantIsSpeaking is currently false, received audio chunk, so setting to true');
-                          }
-                          console.log('adding audio chunk to wavPlayer');
-                          console.log('message.content length:', message.content.length);
-                          const audioBuffer = base64ToArrayBuffer(message.content);
-                          this.wavPlayer.add16BitPCM(audioBuffer, 'default');
-                      }
-                      else {
-                          console.log('ignoring response.audio because assistant has been interrupted');
-                      }
+                      const audioBuffer = base64ToArrayBuffer(message.content);
+                      this.wavPlayer.add16BitPCM(audioBuffer, message.turn_id);
                       break;
                   case 'response.end':
                       console.log('received response.end');
-                      console.log('setting assistantHasBeenInterrupted to false');
-                      this.assistantHasBeenInterrupted = false;
                       break;
                   case 'response.data':
+                      console.log('received response.data', message);
                       this.options.onDataMessage(message);
                       break;
                   default:
@@ -1707,6 +1660,32 @@ registerProcessor('audio_processor', AudioProcessor);
           if (((_a = this.ws) === null || _a === void 0 ? void 0 : _a.readyState) === WebSocket.OPEN) {
               this.ws.send(messageString);
           }
+          else {
+              console.error('WebSocket is not open. Did not send message:', messageString);
+          }
+      }
+      /**
+       * Sets up amplitude monitoring for a given audio source.
+       * @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
+          // 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);
+                      callback(amplitude);
+                      updateCounter = 0; // Reset counter after sampling
+                  }
+                  updateCounter++;
+              });
+          }
       }
       /**
        * Connects to the Layercode pipeline and starts the audio session
@@ -1741,6 +1720,8 @@ registerProcessor('audio_processor', AudioProcessor);
               this.ws = new WebSocket(`${this._websocketUrl}?${new URLSearchParams({
                 client_session_key: authorizeSessionResponseBody.client_session_key,
             })}`);
+              // Bind the websocket message callbacks
+              this.ws.onmessage = this._handleWebSocketMessage;
               this.ws.onopen = () => {
                   console.log('WebSocket connection established');
                   this._setStatus('connected');
@@ -1756,26 +1737,15 @@ registerProcessor('audio_processor', AudioProcessor);
                   this._setStatus('error');
                   this.options.onError(new Error('WebSocket connection error'));
               };
-              this.ws.onmessage = this._handleWebSocketMessage;
-              // Initialize audio
+              // Initialize microphone audio capture
               await this.wavRecorder.begin();
               await this.wavRecorder.record(this._handleDataAvailable);
-              if (this.options.onUserAmplitudeChange !== (() => { })) {
-                  let userUpdateCounter = 0;
-                  this.wavRecorder.startAmplitudeMonitoring((amplitude) => {
-                      if (userUpdateCounter == this.AMPLITUDE_MONITORING_SAMPLE_RATE) {
-                          this.userAudioAmplitude = amplitude;
-                          this.options.onUserAmplitudeChange(amplitude);
-                          userUpdateCounter = 0; // Reset after each sample
-                      }
-                      userUpdateCounter++;
-                  });
-              }
-              await this._setupWavPlayer();
-              // Handle page unload
-              window.addEventListener('beforeunload', () => {
-                  this.disconnect();
-              });
+              // 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));
           }
           catch (error) {
               console.error('Error connecting to Layercode pipeline:', error);
@@ -1784,47 +1754,6 @@ registerProcessor('audio_processor', AudioProcessor);
               throw error;
           }
       }
-      /**
-       * Disconnects from the Layercode pipeline and stops audio recording
-       */
-      disconnect() {
-          console.log('disconnecting');
-          if (this.ws) {
-              this.ws.close();
-              this.ws = null;
-          }
-          // Stop recording user microphone audio
-          this.wavRecorder.stop();
-          // Handle wavPlayer cleanup without calling disconnect directly
-          if (this.wavPlayer) {
-              // Use type assertion to access internal properties
-              const player = this.wavPlayer;
-              // Clean up any audio resources manually
-              if (player.stream) {
-                  player.stream.disconnect();
-                  player.stream = null;
-              }
-              if (player.analyser) {
-                  player.analyser.disconnect();
-              }
-              if (player.context) {
-                  player.context.close().catch((err) => console.error('Error closing audio context:', err));
-              }
-          }
-          this._setStatus('disconnected');
-      }
-      /**
-       * Mutes or unmutes the microphone
-       * @param {boolean} mute - Whether to mute the microphone
-       */
-      setMuteMic(mute) {
-          if (mute) {
-              this.wavRecorder.mute();
-          }
-          else {
-              this.wavRecorder.unmute();
-          }
-      }
   }
 
   return LayercodeClient;