@convai/web-sdk 1.3.1-beta.0 → 1.4.0-beta.0

package/dist/core/ConvaiClient.js

@@ -6,6 +6,7 @@ import { MessageHandler } from "./MessageHandler";
 import { EventEmitter } from "./EventEmitter";
 import { MemoryManager } from "./MemoryManager";
 import { ConnectionStateHandler } from "./ConnectionStateHandler";
+import { WebSocketSession } from "./WebSocketSession";
 /**
  * Custom reconnect policy that disables automatic reconnection
  */
@@ -64,6 +65,8 @@ export class ConvaiClient extends EventEmitter {
         this._storedConfig = null;
         this._endUserId = null;
         this._endUserMetadata = null;
+        this._wsSession = null;
+        this._activeTransport = null;
         // Conversation session tracking
         this._conversationSessionId = 0;
         this._conversationStartTime = 0;
@@ -209,7 +212,25 @@ export class ConvaiClient extends EventEmitter {
             this.updateState({ emotion });
         });
         this._messageHandler.on("listeningChange", (isListening) => {
+            const wasListening = this._state.isListening;
             this.updateState({ isListening });
+            // Voice input path — activate the blendshape queue as soon as the user
+            // starts speaking (user-started-speaking) so conversationActive is true
+            // immediately, matching the text-input path where it's true on send.
+            if (!wasListening && isListening) {
+                // Reset blendshape queue if mid-conversation, but don't interrupt the server
+                if (this.blendshapeQueue.isConversationActive() ||
+                    this._state.isSpeaking) {
+                    this.blendshapeQueue.interrupt();
+                }
+                this._conversationSessionId++;
+                this._conversationStartTime = Date.now();
+                this.emit("conversationStart", {
+                    sessionId: this._conversationSessionId,
+                    userMessage: "[voice]",
+                    timestamp: this._conversationStartTime,
+                });
+            }
         });
         // Handle metrics events
         this._messageHandler.on("metrics", (metricsData) => {
@@ -240,6 +261,31 @@ export class ConvaiClient extends EventEmitter {
         this._messageHandler.on("llmNoResponse", () => {
             this.emit("llmNoResponse");
         });
+        // Forward bot-output event (aggregated output with spoken status)
+        this._messageHandler.on("botOutput", (data) => {
+            this.emit("botOutput", data);
+        });
+        // Forward bot TTS text (word-by-word as spoken)
+        this._messageHandler.on("botTtsText", (data) => {
+            this.emit("botTtsText", data);
+        });
+        // Forward bot TTS lifecycle events
+        this._messageHandler.on("botTtsStarted", () => {
+            this.emit("botTtsStarted");
+        });
+        this._messageHandler.on("botTtsStopped", () => {
+            this.emit("botTtsStopped");
+        });
+        // Forward server-side muting events
+        this._messageHandler.on("userMuteStarted", () => {
+            this.emit("userMuteStarted");
+        });
+        this._messageHandler.on("userMuteStopped", () => {
+            this.emit("userMuteStopped");
+        });
+        this._messageHandler.on("actionResponse", (data) => {
+            this.emit("actionResponse", data);
+        });
     }
     /**
      * Setup MessageHandler to respond to conversation start events
@@ -249,7 +295,6 @@ export class ConvaiClient extends EventEmitter {
     setupMessageHandlerEvents() {
         this.on("conversationStart", (data) => {
             this._messageHandler.getBlendshapeQueue().startConversation();
-            console.log(`[ConvaiClient] 🎬 Blendshape queue activated for conversation ${data.sessionId}`);
         });
     }
     /**
@@ -279,6 +324,30 @@ export class ConvaiClient extends EventEmitter {
             this.emit("stateChange", this._state);
         }
     }
+    /**
+     * Send a data message via the active transport.
+     * For LiveKit: publishes via the data channel.
+     * For WebSocket: sends via PipecatClient.sendClientMessage (wrapped in {t,d} envelope).
+     */
+    publishMessage(type, data) {
+        if (this._activeTransport === "websocket" && this._wsSession?.isConnected) {
+            this._wsSession.sendMessage(type, data);
+        }
+        else if (this._room?.localParticipant &&
+            this._room.state !== "disconnected") {
+            const encodedData = new TextEncoder().encode(JSON.stringify({ type, data }));
+            this._room.localParticipant.publishData(encodedData, { reliable: true });
+        }
+    }
+    /**
+     * Returns true when a message can be sent on the active transport.
+     */
+    isTransportReady() {
+        if (this._activeTransport === "websocket") {
+            return this._wsSession?.isConnected ?? false;
+        }
+        return (!!this._room?.localParticipant && this._room.state !== "disconnected");
+    }
     /**
      * Connect to a Convai character
      */
@@ -315,6 +384,8 @@ export class ConvaiClient extends EventEmitter {
             // Determine connection type based on enableVideo
             const connType = configWithDefaults.enableVideo ? "video" : "audio";
             this._connectionType = connType;
+            const transportType = configWithDefaults.transport ?? "livekit";
+            this._activeTransport = transportType;
             // Prepare request body with required parameters
             const characterSessionIdToSend = configWithDefaults.characterSessionId ?? this._characterSessionId;
             const requestBody = {
@@ -325,7 +396,7 @@ export class ConvaiClient extends EventEmitter {
                 ...(configWithDefaults.endUserMetadata != null && {
                     end_user_metadata: configWithDefaults.endUserMetadata,
                 }),
-                transport: "livekit",
+                transport: transportType,
                 connection_type: connType,
                 blendshape_provider: configWithDefaults.enableLipsync
                     ? "neurosync"
@@ -338,7 +409,7 @@ export class ConvaiClient extends EventEmitter {
                     output_fps: 90,
                 },
                 llm_provider: "dynamic",
-                ...(configWithDefaults.enableEmotion !== false && {
+                ...(configWithDefaults.enableEmotion === true && {
                     emotion_config: {
                         provider: configWithDefaults.emotionConfig?.provider ?? "llm",
                         min_word_threshold: configWithDefaults.emotionConfig?.min_word_threshold ?? 3,
@@ -356,19 +427,14 @@ export class ConvaiClient extends EventEmitter {
                     character_session_id: characterSessionIdToSend,
                 }),
                 ...(configWithDefaults.actionConfig && {
-                    action_config: configWithDefaults.actionConfig,
-                }),
-                ...(configWithDefaults.characters && {
-                    characters: configWithDefaults.characters,
-                }),
-                ...(configWithDefaults.objects && {
-                    objects: configWithDefaults.objects,
-                }),
-                ...(configWithDefaults.currentAttentionObject && {
-                    current_attention_object: configWithDefaults.currentAttentionObject,
-                }),
-                ...(configWithDefaults.sceneDescription && {
-                    scene_description: configWithDefaults.sceneDescription,
+                    action_config: {
+                        actions: configWithDefaults.actionConfig.actions,
+                        objects: configWithDefaults.actionConfig.objects,
+                        characters: configWithDefaults.actionConfig.characters,
+                        ...(configWithDefaults.actionConfig.current_attention_object && {
+                            current_attention_object: configWithDefaults.actionConfig.current_attention_object,
+                        }),
+                    },
                 }),
                 ...(configWithDefaults.dynamicInfo && {
                     dynamic_info: {
@@ -383,24 +449,26 @@ export class ConvaiClient extends EventEmitter {
                 }),
                 invocation_metadata: {
                     source: configWithDefaults.invocationMetadata?.source ?? "web_sdk",
-                    client_version: configWithDefaults.invocationMetadata?.clientVersion ?? "1.2.2-beta.4",
+                    client_version: configWithDefaults.invocationMetadata?.clientVersion ??
+                        "1.3.2-beta.0",
                     ...(configWithDefaults.invocationMetadata?.extraMetadata && {
                         extra_metadata: configWithDefaults.invocationMetadata.extraMetadata,
                     }),
                 },
             };
-            const headers = {
+            const connectHeaders = {
                 "Content-Type": "application/json",
             };
             if (configWithDefaults.authToken) {
-                headers["API-AUTH-TOKEN"] = configWithDefaults.authToken;
+                connectHeaders["API-AUTH-TOKEN"] = configWithDefaults.authToken;
             }
             else if (configWithDefaults.apiKey) {
-                headers["X-API-Key"] = configWithDefaults.apiKey;
+                connectHeaders["X-API-Key"] = configWithDefaults.apiKey;
             }
+            // HTTP POST /connect — same request for both transports
             const response = await fetch(`${configWithDefaults.url}/connect`, {
                 method: "POST",
-                headers,
+                headers: connectHeaders,
                 body: JSON.stringify(requestBody),
             });
             if (!response.ok) {
@@ -426,7 +494,7 @@ export class ConvaiClient extends EventEmitter {
                 throw new Error(errorMessage);
             }
             const connectionData = await response.json();
-            // Capture character_session_id from connection response and persist in stored config for reconnection
+            // Capture session identifiers from /connect response
             if (connectionData.character_session_id) {
                 this._characterSessionId = connectionData.character_session_id;
                 this._storedConfig = {
@@ -434,39 +502,87 @@ export class ConvaiClient extends EventEmitter {
                     characterSessionId: connectionData.character_session_id,
                 };
             }
-            // Capture end_user_id and end_user_metadata from connection response
             if (connectionData.end_user_id) {
                 this._endUserId = connectionData.end_user_id;
             }
             if (connectionData.end_user_metadata) {
                 this._endUserMetadata = connectionData.end_user_metadata;
             }
-            // Connect to LiveKit room
-            await this._room.connect(connectionData.room_url, connectionData.token, {
-                rtcConfig: {
-                    iceTransportPolicy: "relay",
-                },
-            });
-            // Enable microphone only if startWithAudioOn is true (default: false)
-            // If false, microphone stays off until user enables it via audioControls
-            if (configWithDefaults.startWithAudioOn) {
-                await this._room.localParticipant.setMicrophoneEnabled(true, {
-                    echoCancellation: this._audioSettings.echoCancellation,
-                    noiseSuppression: this._audioSettings.noiseSuppression,
-                    autoGainControl: this._audioSettings.autoGainControl,
-                    sampleRate: this._audioSettings.sampleRate,
-                    channelCount: this._audioSettings.channelCount,
+            if (transportType === "websocket") {
+                // ── WebSocket (Pipecat) transport path ────────────────────────────
+                // Server returns the WebSocket URL in room_url (same field as LiveKit).
+                const wsUrl = connectionData.room_url;
+                if (!wsUrl) {
+                    throw new Error("No WebSocket URL returned from /connect endpoint (expected room_url)");
+                }
+                // Always enable mic at construction so WavMediaManager initializes the
+                // audio stream during connect(). If startWithAudioOn is false, we mute
+                // after the connection is established (enableMic(false) works once the
+                // stream exists, but not before it is initialized).
+                this._wsSession = new WebSocketSession((payload) => this._messageHandler.handleDataReceivedPublic(payload), true);
+                this._wsSession.on("botAudioTrack", (track) => {
+                    this.emit("botAudioTrack", track);
                 });
+                this._wsSession.on("disconnected", () => {
+                    this._connectionStateHandler.handleDisconnected();
+                });
+                this._audioManager.setWebSocketSession(this._wsSession);
+                // Wait for WebSocket transport to connect (fires before bot-ready)
+                await new Promise((resolve, reject) => {
+                    const onConnected = () => {
+                        this._wsSession.off("connected", onConnected);
+                        this._wsSession.off("error", onError);
+                        resolve();
+                    };
+                    const onError = (err) => {
+                        this._wsSession.off("connected", onConnected);
+                        this._wsSession.off("error", onError);
+                        reject(err instanceof Error ? err : new Error(String(err)));
+                    };
+                    this._wsSession.on("connected", onConnected);
+                    this._wsSession.on("error", onError);
+                    // connectWithUrl calls initDevices() then connect({ wsUrl }) — matches sandbox flow
+                    this._wsSession.connectWithUrl(wsUrl).catch((err) => {
+                        this._wsSession.off("connected", onConnected);
+                        this._wsSession.off("error", onError);
+                        reject(err instanceof Error ? err : new Error(String(err)));
+                    });
+                });
+                // For WebSocket, mic is already streaming after connect.
+                // Only mute if the caller explicitly sets startWithAudioOn: false.
+                // Defaulting to on matches the sandbox behavior and ensures the bot
+                // sees audio when it initializes (avoids server "tap mic to talk" prompt).
+                if (configWithDefaults.startWithAudioOn === false) {
+                    this._wsSession.enableMic(false);
+                    this._audioManager.syncWsAudioState(false);
+                }
+                else {
+                    this._audioManager.syncWsAudioState(true);
+                }
             }
-            // Enable camera only if enableVideo is true AND startWithVideoOn is true
-            if (configWithDefaults.enableVideo &&
-                configWithDefaults.startWithVideoOn) {
-                await this._room.localParticipant.setCameraEnabled(true);
+            else {
+                // ── LiveKit transport path (default) ─────────────────────────────
+                await this._room.connect(connectionData.room_url, connectionData.token, {
+                    rtcConfig: {
+                        iceTransportPolicy: "relay",
+                    },
+                });
+                if (configWithDefaults.startWithAudioOn) {
+                    await this._room.localParticipant.setMicrophoneEnabled(true, {
+                        echoCancellation: this._audioSettings.echoCancellation,
+                        noiseSuppression: this._audioSettings.noiseSuppression,
+                        autoGainControl: this._audioSettings.autoGainControl,
+                        sampleRate: this._audioSettings.sampleRate,
+                        channelCount: this._audioSettings.channelCount,
+                    });
+                }
+                if (configWithDefaults.enableVideo &&
+                    configWithDefaults.startWithVideoOn) {
+                    await this._room.localParticipant.setCameraEnabled(true);
+                }
+                this._audioManager.syncStateFromRoom({ emit: true });
+                this._participantSid = this._room.localParticipant.sid;
             }
-            // Ensure audio manager mirrors the actual microphone permission state
-            this._audioManager.syncStateFromRoom({ emit: true });
-            // Capture participant SID
-            this._participantSid = this._room.localParticipant.sid;
             // Apply custom mapper to blendshape queue if provided
             if (configWithDefaults.blendshapeConfig?.customMapper) {
                 this.blendshapeQueue.setMapper(configWithDefaults.blendshapeConfig.customMapper);
@@ -505,7 +621,18 @@ export class ConvaiClient extends EventEmitter {
      * Disconnect from the current character session
      */
     async disconnect() {
-        if (this._room && this._room.state !== "disconnected") {
+        if (this._activeTransport === "websocket" && this._wsSession) {
+            try {
+                await this._wsSession.disconnect();
+            }
+            catch {
+                // ignore disconnect errors
+            }
+            this._wsSession = null;
+            this._connectionStateHandler.resetConnectionState();
+            this.clearAllManagers();
+        }
+        else if (this._room && this._room.state !== "disconnected") {
             try {
                 await this._room.disconnect();
                 this._connectionStateHandler.resetConnectionState();
@@ -523,6 +650,8 @@ export class ConvaiClient extends EventEmitter {
      */
     clearAllManagers() {
         this._connectionType = null;
+        this._activeTransport = null;
+        this._wsSession = null;
         this._apiKey = null;
         this._authToken = null;
         this._characterId = null;
@@ -530,6 +659,7 @@ export class ConvaiClient extends EventEmitter {
         this._endUserId = null;
         this._endUserMetadata = null;
         this._memoryManager = null; // Clear memory manager on disconnect
+        this._audioManager.setWebSocketSession(null);
         this._audioManager.reset();
         this._videoManager.reset();
         this._screenShareManager.reset();
@@ -556,35 +686,28 @@ export class ConvaiClient extends EventEmitter {
      * Send a text message to the character
      */
     sendUserTextMessage(text) {
-        if (!this._room ||
-            this._room.state === "disconnected" ||
-            !this._room.localParticipant) {
+        if (!this.isTransportReady())
             return;
-        }
-        if (!text || !text.trim()) {
+        if (!text || !text.trim())
             return;
-        }
         try {
+            // Reset blendshape queue if mid-conversation, but don't interrupt the server
+            if (this.blendshapeQueue.isConversationActive() ||
+                this._state.isSpeaking) {
+                this.blendshapeQueue.interrupt();
+            }
             // Start new conversation session
             this._conversationSessionId++;
             this._conversationStartTime = Date.now();
-            console.log(`------conversation ${this._conversationSessionId}-------`);
             // Emit conversation start event
             this.emit("conversationStart", {
                 sessionId: this._conversationSessionId,
                 userMessage: text.trim(),
                 timestamp: this._conversationStartTime,
             });
-            const message = {
-                type: "user_text_message",
-                data: {
-                    text: text.trim(),
-                    participant_sid: this._participantSid || this._room.localParticipant.sid,
-                },
-            };
-            const encodedData = new TextEncoder().encode(JSON.stringify(message));
-            this._room.localParticipant.publishData(encodedData, {
-                reliable: true,
+            this.publishMessage("user_text_message", {
+                text: text.trim(),
+                participant_sid: this._participantSid || this._room.localParticipant?.sid,
             });
         }
         catch (error) {
@@ -595,44 +718,61 @@ export class ConvaiClient extends EventEmitter {
      * Send a trigger message to invoke specific character actions
      */
     sendTriggerMessage(triggerName, triggerMessage) {
-        if (this._room && this._room.localParticipant) {
-            const message = {
-                type: "trigger-message",
-                data: {
-                    ...(triggerName && { trigger_name: triggerName }),
-                    ...(triggerMessage && { trigger_message: triggerMessage }),
-                    participant_sid: this._participantSid || this._room.localParticipant.sid,
-                },
-            };
-            const encodedData = new TextEncoder().encode(JSON.stringify(message));
-            this._room.localParticipant.publishData(encodedData, {
-                reliable: true,
+        if (!this.isTransportReady())
+            return;
+        // Reset blendshape queue if mid-conversation, but don't interrupt the server
+        if (this.blendshapeQueue.isConversationActive() || this._state.isSpeaking) {
+            this.blendshapeQueue.interrupt();
+        }
+        this._conversationSessionId++;
+        this._conversationStartTime = Date.now();
+        this.emit("conversationStart", {
+            sessionId: this._conversationSessionId,
+            userMessage: `[trigger:${triggerName ?? ""}]`,
+            timestamp: this._conversationStartTime,
+        });
+        this.publishMessage("trigger-message", {
+            ...(triggerName && { trigger_name: triggerName }),
+            ...(triggerMessage && { trigger_message: triggerMessage }),
+            participant_sid: this._participantSid || this._room.localParticipant?.sid,
+        });
+    }
+    /**
+     * If the bot is currently speaking or a conversation is active, send an
+     * interrupt to the server and end the blendshape conversation so the queue
+     * is clean before a new response starts arriving.
+     */
+    endCurrentConversationIfActive() {
+        const queueActive = this.blendshapeQueue.isConversationActive();
+        const botSpeaking = this._state.isSpeaking;
+        if (!queueActive && !botSpeaking)
+            return;
+        if (this.isTransportReady()) {
+            this.publishMessage("interrupt-bot", {
+                participant_sid: this._participantSid || this._room.localParticipant?.sid,
             });
         }
+        // End the blendshape queue so the lipsync player finishes cleanly
+        this.blendshapeQueue.interrupt();
     }
     /**
      * Send an interrupt message to stop the bot's current response
      */
     sendInterruptMessage() {
-        if (!this._room ||
-            this._room.state === "disconnected" ||
-            !this._room.localParticipant) {
+        if (!this.isTransportReady())
             return;
-        }
         try {
-            const message = {
-                type: "interrupt-bot",
-                data: {
-                    participant_sid: this._participantSid || this._room.localParticipant.sid,
-                },
-            };
-            const encodedData = new TextEncoder().encode(JSON.stringify(message));
-            this._room.localParticipant.publishData(encodedData, {
-                reliable: true,
+            this.publishMessage("interrupt-bot", {
+                participant_sid: this._participantSid || this._room.localParticipant?.sid,
             });
-            // Trigger fade out for interruption - keeps last 10 frames
-            if (this.blendshapeQueue) {
-                this.blendshapeQueue.interrupt();
+            // Blendshape fade-out only for LiveKit (WebSocket transport has no lipsync;
+            // calling interrupt() would set conversationEnded=true and block the next
+            // bot-started-speaking from ever firing isSpeaking).
+            if (this._activeTransport !== "websocket") {
+                if (this.blendshapeQueue.isConversationActive() ||
+                    this._state.isSpeaking) {
+                    this.blendshapeQueue.interrupt();
+                }
             }
         }
         catch (error) {
@@ -643,39 +783,23 @@ export class ConvaiClient extends EventEmitter {
      * Update template keys in the character's context
      */
     updateTemplateKeys(templateKeys) {
-        if (this._room &&
-            this._room.localParticipant &&
-            Object.keys(templateKeys).length > 0) {
-            const message = {
-                type: "update-template-keys",
-                data: {
-                    template_keys: templateKeys,
-                    participant_sid: this._participantSid || this._room.localParticipant.sid,
-                },
-            };
-            const encodedData = new TextEncoder().encode(JSON.stringify(message));
-            this._room.localParticipant.publishData(encodedData, {
-                reliable: true,
-            });
-        }
+        if (!this.isTransportReady() || Object.keys(templateKeys).length === 0)
+            return;
+        this.publishMessage("update-template-keys", {
+            template_keys: templateKeys,
+            participant_sid: this._participantSid || this._room.localParticipant?.sid,
+        });
     }
     /**
      * Update dynamic information about the current context
      */
     updateDynamicInfo(dynamicInfo) {
-        if (this._room && this._room.localParticipant && dynamicInfo?.trim()) {
-            const message = {
-                type: "update-dynamic-info",
-                data: {
-                    dynamic_info: { text: dynamicInfo },
-                    participant_sid: this._participantSid || this._room.localParticipant.sid,
-                },
-            };
-            const encodedData = new TextEncoder().encode(JSON.stringify(message));
-            this._room.localParticipant.publishData(encodedData, {
-                reliable: true,
-            });
-        }
+        if (!this.isTransportReady() || !dynamicInfo?.trim())
+            return;
+        this.publishMessage("update-dynamic-info", {
+            dynamic_info: { text: dynamicInfo },
+            participant_sid: this._participantSid || this._room.localParticipant?.sid,
+        });
     }
     /**
      * Update the bot's temporary runtime context in a unified way.
@@ -704,79 +828,61 @@ export class ConvaiClient extends EventEmitter {
      * ```
      */
     updateContext(options) {
-        if (!this._room || !this._room.localParticipant) {
+        if (!this.isTransportReady())
             return;
-        }
-        // Validate: text is required unless mode is "reset"
-        if (options.mode !== "reset" && !options.text?.trim()) {
-            console.warn("[ConvaiClient] updateContext: text is required unless mode is 'reset'");
+        const hasText = !!options.text?.trim();
+        const hasAttention = options.current_attention_object !== undefined;
+        // text is required unless mode is "reset" or only updating attention
+        if (options.mode !== "reset" && !hasText && !hasAttention) {
+            console.warn("[ConvaiClient] updateContext: text or current_attention_object is required unless mode is 'reset'");
             return;
         }
-        const message = {
-            type: "context-update",
-            data: {
-                ...(options.text && { text: options.text.trim() }),
-                ...(options.mode && { mode: options.mode }),
-                ...(options.run_llm && { run_llm: options.run_llm }),
-                participant_sid: this._participantSid || this._room.localParticipant.sid,
-            },
-        };
-        const encodedData = new TextEncoder().encode(JSON.stringify(message));
-        this._room.localParticipant.publishData(encodedData, {
-            reliable: true,
+        const willTriggerLlm = options.run_llm !== "false";
+        if (willTriggerLlm) {
+            if (this.blendshapeQueue.isConversationActive() ||
+                this._state.isSpeaking) {
+                this.blendshapeQueue.interrupt();
+            }
+            this._conversationSessionId++;
+            this._conversationStartTime = Date.now();
+            this.emit("conversationStart", {
+                sessionId: this._conversationSessionId,
+                userMessage: `[context-update:${options.mode ?? "append"}]`,
+                timestamp: this._conversationStartTime,
+            });
+        }
+        this.publishMessage("context-update", {
+            ...(hasText && { text: options.text.trim() }),
+            ...(options.mode && { mode: options.mode }),
+            ...(options.run_llm && { run_llm: options.run_llm }),
+            ...(hasAttention && { current_attention_object: options.current_attention_object }),
+            participant_sid: this._participantSid || this._room.localParticipant?.sid,
         });
     }
+    /**
+     * Send descriptive scene updates. Use when environment description changes
+     * and the bot should know what is visible or nearby. Does not modify action_config.
+     */
+    updateSceneMetadata(items) {
+        if (!this.isTransportReady())
+            return;
+        this.publishMessage("update-scene-metadata", { scene_metadata: items });
+    }
     /**
      * Toggle text-to-speech on or off
      */
     toggleTts(enabled) {
-        if (!this._room ||
-            this._room.state === "disconnected" ||
-            !this._room.localParticipant) {
+        if (!this.isTransportReady())
             return;
-        }
-        try {
-            const message = {
-                type: "tts-toggle",
-                data: {
-                    enabled: enabled,
-                },
-            };
-            const encodedData = new TextEncoder().encode(JSON.stringify(message));
-            this._room.localParticipant.publishData(encodedData, {
-                reliable: true,
-            });
-        }
-        catch (error) {
-            throw error;
-        }
+        this.publishMessage("tts-toggle", { enabled });
     }
     /**
      * Toggle speech-to-text on or off
      */
     toggleStt(enabled) {
-        if (!this._room ||
-            this._room.state === "disconnected" ||
-            !this._room.localParticipant) {
+        if (!this.isTransportReady())
             return;
-        }
-        try {
-            const message = {
-                lable: "rtvi-ai",
-                type: "stt-toggle",
-                data: {
-                    muted: !enabled,
-                },
-            };
-            const encodedData = new TextEncoder().encode(JSON.stringify(message));
-            console.log("Toggle Stt: ", enabled, encodedData);
-            this._room.localParticipant.publishData(encodedData, {
-                reliable: true,
-            });
-        }
-        catch (error) {
-            throw error;
-        }
+        this.publishMessage("stt-toggle", { muted: !enabled });
     }
     /**
      * Reset the server-side idle timer.
@@ -784,26 +890,11 @@ export class ConvaiClient extends EventEmitter {
      * the session from being disconnected due to inactivity.
      */
     resetIdleTimer() {
-        if (!this._room ||
-            this._room.state === "disconnected" ||
-            !this._room.localParticipant) {
+        if (!this.isTransportReady())
             return;
-        }
-        try {
-            const message = {
-                type: "reset-idle-timer",
-                data: {
-                    participant_sid: this._participantSid || this._room.localParticipant.sid,
-                },
-            };
-            const encodedData = new TextEncoder().encode(JSON.stringify(message));
-            this._room.localParticipant.publishData(encodedData, {
-                reliable: true,
-            });
-        }
-        catch (error) {
-            throw error;
-        }
+        this.publishMessage("reset-idle-timer", {
+            participant_sid: this._participantSid || this._room.localParticipant?.sid,
+        });
     }
 }
 //# sourceMappingURL=ConvaiClient.js.map