@convai/web-sdk 0.3.1-beta.2 → 0.3.2-beta.0

package/dist/{types/core → core}/ConvaiClient.d.ts

@@ -2,6 +2,7 @@ import { Room } from "livekit-client";
 import { ConvaiConfig, ConvaiClientState, ChatMessage, IConvaiClient, AudioControls, VideoControls, ScreenShareControls } from "./types";
 import { EventEmitter } from "./EventEmitter";
 import { LatencyMonitor } from "../utils/LatencyMonitor";
+import { BlendshapeQueue } from "./BlendshapeQueue";
 /**
  * Main Convai client class for managing AI voice assistant connections
  * Provides complete interface for connecting to Convai's voice assistants,
@@ -55,6 +56,8 @@ export declare class ConvaiClient extends EventEmitter implements IConvaiClient
     private _screenShareManager;
     private _messageHandler;
     private _latencyMonitor;
+    private _conversationSessionId;
+    private _conversationStartTime;
     constructor(config?: ConvaiConfig);
     get state(): ConvaiClientState;
     get connectionType(): "audio" | "video" | null;
@@ -70,21 +73,8 @@ export declare class ConvaiClient extends EventEmitter implements IConvaiClient
     get videoControls(): VideoControls;
     get screenShareControls(): ScreenShareControls;
     get latencyMonitor(): LatencyMonitor;
-    /**
-     * Whether the user's microphone is currently muted
-     * Convenience getter - equivalent to audioControls.isAudioMuted
-     */
-    get isAudioMuted(): boolean;
-    /**
-     * Whether the user's video is currently enabled
-     * Convenience getter - equivalent to videoControls.isVideoEnabled
-     */
-    get isVideoEnabled(): boolean;
-    /**
-     * Whether screen sharing is currently active
-     * Convenience getter - equivalent to screenShareControls.isScreenShareActive
-     */
-    get isScreenShareActive(): boolean;
+    get blendshapeQueue(): BlendshapeQueue;
+    get conversationSessionId(): number;
     /**
      * Setup event listeners for room and managers
      */
@@ -149,5 +139,19 @@ export declare class ConvaiClient extends EventEmitter implements IConvaiClient
      * Toggle text-to-speech on or off
      */
     toggleTts(enabled: boolean): void;
+    /**
+     * Add a post-processor to modify blendshape frames during playback
+     * @param processor - Function that processes blendshape frames
+     */
+    addLipsyncPostProcessor(processor: import("./BlendshapeQueue").BlendshapePostProcessor): void;
+    /**
+     * Remove a post-processor
+     * @param processor - The processor function to remove
+     */
+    removeLipsyncPostProcessor(processor: import("./BlendshapeQueue").BlendshapePostProcessor): void;
+    /**
+     * Clear all post-processors
+     */
+    clearLipsyncPostProcessors(): void;
 }
 //# sourceMappingURL=ConvaiClient.d.ts.map

package/dist/core/ConvaiClient.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ConvaiClient.d.ts","sourceRoot":"","sources":["../../src/core/ConvaiClient.ts"],"names":[],"mappings":"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"}

package/dist/core/ConvaiClient.js

@@ -0,0 +1,623 @@
+import { Room, RoomEvent } from "livekit-client";
+import { AudioManager } from "./AudioManager";
+import { VideoManager } from "./VideoManager";
+import { ScreenShareManager } from "./ScreenShareManager";
+import { MessageHandler } from "./MessageHandler";
+import { EventEmitter } from "./EventEmitter";
+import { resolveSpeakerId } from "../utils/speakerManagement";
+import { LatencyMonitor } from "../utils/LatencyMonitor";
+/**
+ * Main Convai client class for managing AI voice assistant connections
+ * Provides complete interface for connecting to Convai's voice assistants,
+ * managing real-time audio/video conversations, and handling messages.
+ *
+ * @example
+ * ```typescript
+ * import { ConvaiClient } from '@convai/web-sdk/core';
+ *
+ * // Recommended: Pass config to constructor
+ * const client = new ConvaiClient({
+ *   apiKey: 'your-api-key',
+ *   characterId: 'your-character-id',
+ *   endUserId: 'user-uuid', // Optional: enables memory & analytics
+ *   enableVideo: true,
+ * });
+ *
+ * // Listen for state changes
+ * client.on('stateChange', (state) => {
+ *   console.log('State:', state);
+ * });
+ *
+ * // Connect (uses stored config from constructor)
+ * await client.connect();
+ *
+ * // Send a message
+ * client.sendUserTextMessage('Hello!');
+ *
+ * // Advanced: Override config or connect without constructor config
+ * await client.connect({ apiKey: 'different-key', characterId: 'different-id' });
+ *
+ * // Disconnect and reconnect
+ * await client.disconnect();
+ * await client.reconnect();
+ * ```
+ */
+export class ConvaiClient extends EventEmitter {
+    constructor(config) {
+        super();
+        this._connectionType = null;
+        this._apiKey = null;
+        this._characterId = null;
+        this._speakerId = null;
+        this._characterSessionId = "-1";
+        this._isBotReady = false;
+        this._participantSid = "";
+        this._storedConfig = null;
+        // Conversation session tracking
+        this._conversationSessionId = 0;
+        this._conversationStartTime = 0;
+        // Store config if provided
+        if (config) {
+            this._storedConfig = config;
+        }
+        // Initialize room
+        this._room = new Room();
+        // Initialize state
+        this._state = {
+            isConnected: false,
+            isConnecting: false,
+            isListening: false,
+            isThinking: false,
+            isSpeaking: false,
+            agentState: "disconnected",
+        };
+        // Default audio settings for optimal interruption handling
+        this._audioSettings = {
+            echoCancellation: true,
+            noiseSuppression: true,
+            autoGainControl: true,
+            sampleRate: 48000,
+            channelCount: 1,
+        };
+        // Initialize managers
+        this._audioManager = new AudioManager(this._room);
+        this._videoManager = new VideoManager(this._room);
+        this._screenShareManager = new ScreenShareManager(this._room);
+        this._latencyMonitor = new LatencyMonitor(false); // Disabled by default
+        this._messageHandler = new MessageHandler(this._room, this._latencyMonitor);
+        // Setup event listeners
+        this.setupEventListeners();
+    }
+    // Getters
+    get state() {
+        return { ...this._state };
+    }
+    get connectionType() {
+        return this._connectionType;
+    }
+    get apiKey() {
+        return this._apiKey;
+    }
+    get characterId() {
+        return this._characterId;
+    }
+    get speakerId() {
+        return this._speakerId;
+    }
+    get room() {
+        return this._room;
+    }
+    get chatMessages() {
+        return this._messageHandler.getChatMessages();
+    }
+    get userTranscription() {
+        return this._messageHandler.getUserTranscription();
+    }
+    get characterSessionId() {
+        return this._characterSessionId;
+    }
+    get isBotReady() {
+        return this._isBotReady;
+    }
+    get audioControls() {
+        return this._audioManager;
+    }
+    get videoControls() {
+        return this._videoManager;
+    }
+    get screenShareControls() {
+        return this._screenShareManager;
+    }
+    get latencyMonitor() {
+        return this._latencyMonitor;
+    }
+    get blendshapeQueue() {
+        return this._messageHandler.getBlendshapeQueue();
+    }
+    get conversationSessionId() {
+        return this._conversationSessionId;
+    }
+    /**
+     * Setup event listeners for room and managers
+     */
+    setupEventListeners() {
+        // Room event listeners
+        this._room.on(RoomEvent.Disconnected, this.handleDisconnected.bind(this));
+        this._room.on(RoomEvent.ConnectionStateChanged, this.handleConnectionStateChanged.bind(this));
+        // Message handler events
+        this._messageHandler.on("botReady", () => {
+            this._isBotReady = true;
+            this.updateState({ isConnected: true });
+            this.emit("botReady");
+        });
+        this._messageHandler.on("messagesChange", (messages) => {
+            this.emit("message", messages[messages.length - 1]);
+            this.emit("messagesChange", messages);
+        });
+        this._messageHandler.on("userTranscriptionChange", (transcription) => {
+            this.emit("userTranscriptionChange", transcription);
+        });
+        this._messageHandler.on("speakingChange", (isSpeaking) => {
+            this.updateState({ isSpeaking });
+            this.emit("speakingChange", isSpeaking);
+            // End latency measurement when bot starts speaking
+            if (isSpeaking) {
+                this._latencyMonitor.endMeasurement();
+            }
+            else if (this._conversationSessionId > 0) {
+                // Bot stopped speaking - conversation end
+                const duration = ((Date.now() - this._conversationStartTime) /
+                    1000).toFixed(2);
+                this.emit("conversationEnd", {
+                    sessionId: this._conversationSessionId,
+                    duration: parseFloat(duration),
+                    timestamp: Date.now(),
+                });
+            }
+        });
+        this._messageHandler.on("botRespondingChange", (isResponding) => {
+            this.updateState({ isThinking: isResponding });
+        });
+        // Forward blendshapes events
+        this._messageHandler.on("blendshapes", (data) => {
+            this.emit("blendshapes", data);
+        });
+        // Forward blendshape stats event (conversation end marker)
+        this._messageHandler.on("blendshapeStatsReceived", (stats) => {
+            this.emit("blendshapeStatsReceived", stats);
+        });
+        // Forward latency monitor events
+        this._latencyMonitor.on("measurement", (measurement) => {
+            this.emit("latencyMeasurement", measurement);
+        });
+    }
+    /**
+     * Handle room disconnection
+     */
+    handleDisconnected() {
+        this.updateState({
+            isConnected: false,
+            isConnecting: false,
+            isSpeaking: false,
+            isThinking: false,
+            isListening: false,
+        });
+        this._isBotReady = false;
+        this._messageHandler.reset();
+        this.emit("disconnect");
+    }
+    /**
+     * Handle connection state changes
+     */
+    handleConnectionStateChanged(state) {
+        if (state === "disconnected") {
+            this.updateState({
+                isConnected: false,
+                isConnecting: false,
+            });
+            this._isBotReady = false;
+            this._messageHandler.reset();
+        }
+        else if (state === "connected") {
+            this.updateState({
+                isConnected: true,
+                isConnecting: false,
+            });
+            this._isBotReady = false; // Wait for bot-ready message
+        }
+        else if (state === "connecting") {
+            this.updateState({
+                isConnecting: true,
+                isConnected: false,
+            });
+            this._isBotReady = false;
+        }
+    }
+    /**
+     * Update state and emit changes
+     */
+    updateState(updates) {
+        const oldState = { ...this._state };
+        this._state = { ...this._state, ...updates };
+        // Update agentState based on individual flags
+        if (!this._state.isConnected) {
+            this._state.agentState = "disconnected";
+        }
+        else if (this._state.isSpeaking) {
+            this._state.agentState = "speaking";
+        }
+        else if (this._state.isThinking) {
+            this._state.agentState = "thinking";
+        }
+        else if (this._state.isListening) {
+            this._state.agentState = "listening";
+        }
+        else {
+            this._state.agentState = "connected";
+        }
+        // Emit state change if changed
+        if (JSON.stringify(oldState) !== JSON.stringify(this._state)) {
+            this.emit("stateChange", this._state);
+        }
+    }
+    /**
+     * Connect to a Convai character
+     */
+    async connect(config) {
+        // Use provided config or stored config
+        const finalConfig = config || this._storedConfig;
+        if (!finalConfig) {
+            throw new Error("No configuration provided. Pass config to connect() or store it in the client");
+        }
+        // Store config for reconnection
+        this._storedConfig = finalConfig;
+        // Add default URL if not provided
+        const configWithDefaults = {
+            url: "https://realtime-api.convai.com",
+            ...finalConfig,
+        };
+        if (!configWithDefaults.apiKey || !configWithDefaults.characterId) {
+            throw new Error("apiKey and characterId are required");
+        }
+        this.updateState({ isConnecting: true });
+        try {
+            // Store connection config
+            this._apiKey = configWithDefaults.apiKey;
+            this._characterId = configWithDefaults.characterId;
+            // Resolve speaker ID based on endUserId
+            const resolvedSpeakerId = await resolveSpeakerId(configWithDefaults.endUserId, configWithDefaults.apiKey);
+            this._speakerId = resolvedSpeakerId;
+            // Determine connection type based on enableVideo
+            const connType = configWithDefaults.enableVideo ? "video" : "audio";
+            this._connectionType = connType;
+            // Prepare request body with required parameters
+            const requestBody = {
+                character_id: configWithDefaults.characterId,
+                ...(resolvedSpeakerId && { speaker_id: resolvedSpeakerId }),
+                transport: "livekit",
+                connection_type: connType,
+                blendshape_provider: configWithDefaults.blendshapeProvider || "neurosync",
+                blendshape_config: {
+                    enable_chunking: true,
+                    chunk_size: 10,
+                    format: configWithDefaults.blendshapeConfig?.format || "mha",
+                    frames_buffer_duration: 2.5,
+                    output_fps: 120,
+                },
+                llm_provider: "dynamic",
+                default_tts_enabled: configWithDefaults.ttsEnabled !== undefined
+                    ? configWithDefaults.ttsEnabled
+                    : true,
+                ...(this._characterSessionId &&
+                    this._characterSessionId !== "-1" && {
+                    character_session_id: this._characterSessionId,
+                }),
+                ...(configWithDefaults.actionConfig && {
+                    action_config: configWithDefaults.actionConfig,
+                }),
+            };
+            // Call Core Service API
+            const response = await fetch(`${configWithDefaults.url}/connect`, {
+                method: "POST",
+                headers: {
+                    "x-api-key": configWithDefaults.apiKey,
+                    "Content-Type": "application/json",
+                },
+                body: JSON.stringify(requestBody),
+            });
+            if (!response.ok) {
+                const errorText = await response.text();
+                let errorMessage = `HTTP error! status: ${response.status}`;
+                try {
+                    const errorData = JSON.parse(errorText);
+                    if (errorData.message) {
+                        errorMessage = errorData.message;
+                    }
+                    else if (errorData.error) {
+                        errorMessage = errorData.error;
+                    }
+                    else if (errorData.detail) {
+                        errorMessage = errorData.detail;
+                    }
+                }
+                catch (e) {
+                    if (errorText) {
+                        errorMessage = `${errorMessage}: ${errorText}`;
+                    }
+                }
+                throw new Error(errorMessage);
+            }
+            const connectionData = await response.json();
+            // Capture character_session_id from connection response
+            if (connectionData.character_session_id) {
+                this._characterSessionId = connectionData.character_session_id;
+            }
+            // 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,
+                });
+            }
+            // Enable camera only if enableVideo is true AND startWithVideoOn is true
+            if (configWithDefaults.enableVideo &&
+                configWithDefaults.startWithVideoOn) {
+                await this._room.localParticipant.setCameraEnabled(true);
+            }
+            // Ensure audio manager mirrors the actual microphone permission state
+            this._audioManager.syncStateFromRoom({ emit: true });
+            // Capture participant SID
+            this._participantSid = this._room.localParticipant.sid;
+            this.updateState({
+                isConnected: true,
+                isConnecting: false,
+            });
+            this.emit("connect");
+        }
+        catch (error) {
+            this.updateState({
+                isConnected: false,
+                isConnecting: false,
+            });
+            this.emit("error", error);
+            throw error;
+        }
+    }
+    /**
+     * Disconnect from the current character session
+     */
+    async disconnect() {
+        if (this._room && this._room.state !== "disconnected") {
+            try {
+                await this._room.disconnect();
+                this.resetConnectionState();
+            }
+            catch (error) {
+                // Handle disconnect errors gracefully
+                this.resetConnectionState();
+            }
+        }
+    }
+    /**
+     * Reset connection state
+     */
+    resetConnectionState() {
+        this.updateState({
+            isConnected: false,
+            isConnecting: false,
+            isSpeaking: false,
+            isThinking: false,
+            isListening: false,
+        });
+        this._isBotReady = false;
+        this._connectionType = null;
+        this._apiKey = null;
+        this._characterId = null;
+        this._speakerId = null;
+        this._messageHandler.reset();
+        this._audioManager.reset();
+        this._videoManager.reset();
+        this._screenShareManager.reset();
+    }
+    /**
+     * Reconnect - disconnect and connect again using stored config
+     */
+    async reconnect() {
+        if (!this._storedConfig) {
+            throw new Error("No stored config available for reconnection");
+        }
+        await this.disconnect();
+        await this.connect(this._storedConfig);
+    }
+    /**
+     * Reset the session ID to start a new conversation
+     */
+    resetSession() {
+        this._characterSessionId = "-1";
+        this._messageHandler.reset();
+    }
+    /**
+     * Send a text message to the character
+     */
+    sendUserTextMessage(text) {
+        if (!this._room ||
+            this._room.state === "disconnected" ||
+            !this._room.localParticipant) {
+            return;
+        }
+        if (!text || !text.trim()) {
+            return;
+        }
+        try {
+            // 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,
+            });
+            // Start latency measurement for text message
+            this._latencyMonitor.startMeasurement("text", text.trim());
+            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,
+            });
+        }
+        catch (error) {
+            // Cancel latency measurement on error
+            this._latencyMonitor.cancelMeasurement();
+            throw error;
+        }
+    }
+    /**
+     * 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,
+            });
+        }
+    }
+    /**
+     * Send an interrupt message to stop the bot's current response
+     */
+    sendInterruptMessage() {
+        if (!this._room ||
+            this._room.state === "disconnected" ||
+            !this._room.localParticipant) {
+            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,
+            });
+        }
+        catch (error) {
+            throw error;
+        }
+    }
+    /**
+     * 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,
+            });
+        }
+    }
+    /**
+     * Update dynamic information about the current context
+     */
+    updateDynamicInfo(dynamicInfo) {
+        if (this._room && this._room.localParticipant && dynamicInfo.text?.trim()) {
+            const message = {
+                type: "update-dynamic-info",
+                data: {
+                    dynamic_info: {
+                        text: dynamicInfo.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,
+            });
+        }
+    }
+    /**
+     * Toggle text-to-speech on or off
+     */
+    toggleTts(enabled) {
+        if (!this._room ||
+            this._room.state === "disconnected" ||
+            !this._room.localParticipant) {
+            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;
+        }
+    }
+    // ========== Lipsync Post-Processing Methods ==========
+    /**
+     * Add a post-processor to modify blendshape frames during playback
+     * @param processor - Function that processes blendshape frames
+     */
+    addLipsyncPostProcessor(processor) {
+        this.blendshapeQueue.addPostProcessor(processor);
+    }
+    /**
+     * Remove a post-processor
+     * @param processor - The processor function to remove
+     */
+    removeLipsyncPostProcessor(processor) {
+        this.blendshapeQueue.removePostProcessor(processor);
+    }
+    /**
+     * Clear all post-processors
+     */
+    clearLipsyncPostProcessors() {
+        this.blendshapeQueue.clearPostProcessors();
+    }
+}
+//# sourceMappingURL=ConvaiClient.js.map