@layercode/js-sdk 2.0.2 → 2.0.4

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

@@ -3501,12 +3501,14 @@ class LayercodeClient {
             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.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({
@@ -3528,6 +3530,7 @@ class LayercodeClient {
         this.currentTurnId = null;
         this.audioBuffer = [];
         this.vadConfig = null;
+        this.isMuted = false;
         // this.audioPauseTime = null;
         // Bind event handlers
         this._handleWebSocketMessage = this._handleWebSocketMessage.bind(this);
@@ -3550,16 +3553,20 @@ class LayercodeClient {
         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
@@ -3567,6 +3574,10 @@ class LayercodeClient {
                     type: 'vad_events',
                     event: 'vad_end',
                 });
+                this.options.onMessage({
+                    type: 'vad_events',
+                    event: 'vad_end',
+                });
             },
         };
         // Apply VAD configuration from backend if available
@@ -3625,32 +3636,14 @@ class LayercodeClient {
      * 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) {
@@ -3673,49 +3666,51 @@ class LayercodeClient {
         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) {
@@ -3731,6 +3726,10 @@ class LayercodeClient {
         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
@@ -3748,7 +3747,7 @@ class LayercodeClient {
             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',
@@ -3780,7 +3779,7 @@ class LayercodeClient {
     _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) {
@@ -3853,7 +3852,7 @@ class LayercodeClient {
                 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') {
@@ -3902,7 +3901,7 @@ class LayercodeClient {
     }
     _resetTurnTracking() {
         this.currentTurnId = null;
-        console.log('Reset turn tracking state');
+        console.debug('Reset turn tracking state');
     }
     async disconnect() {
         // Clean up VAD if it exists
@@ -3943,11 +3942,11 @@ class LayercodeClient {
             // 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);
@@ -3959,7 +3958,7 @@ class LayercodeClient {
      */
     async _restartAudioRecording() {
         try {
-            console.log('Restarting audio recording after device switch...');
+            console.debug('Restarting audio recording after device switch...');
             try {
                 await this.wavRecorder.end();
             }
@@ -3971,7 +3970,7 @@ class LayercodeClient {
             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);
@@ -4001,7 +4000,7 @@ class LayercodeClient {
             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) {
@@ -4031,6 +4030,27 @@ class LayercodeClient {
             }
         });
     }
+    /**
+     * 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);
+        }
+    }
 }
 
 export { LayercodeClient as default };