@layercode/js-sdk 1.0.6 → 1.0.7

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

@@ -1510,8 +1510,6 @@ function arrayBufferToBase64(arrayBuffer) {
  * @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
@@ -1541,12 +1539,8 @@ class LayercodeClient {
         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);
@@ -1565,48 +1559,21 @@ class LayercodeClient {
      * @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) {
@@ -1634,33 +1601,20 @@ class LayercodeClient {
             }
             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');
-                        }
-                        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);
@@ -1700,6 +1654,32 @@ class LayercodeClient {
         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
@@ -1734,6 +1714,8 @@ class LayercodeClient {
             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');
@@ -1749,26 +1731,15 @@ class LayercodeClient {
                 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);
@@ -1777,47 +1748,6 @@ class LayercodeClient {
             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();
-        }
-    }
 }
 
 export { LayercodeClient as default };