@voxket-ai/voxket-live 1.0.158 → 1.1.0

package/dist/core/client.d.ts

@@ -1,46 +1,9 @@
-import { default as React } from 'react';
-import { Room, RemoteParticipant, LocalParticipant, ConnectionState, Track } from 'livekit-client';
+import { Room, ConnectionState } from 'livekit-client';
 import { VoxketEventEmitter } from './event-emitter';
 import { PluginManager } from '../plugins/plugin-system';
+import { RenderUIOptions } from './ui-renderer';
 import { VoxketConfig, SessionConfig, VoxketSession, VoxketEvents, SessionState, SessionMetrics, AgentInfo, ParticipantInfo, ChatMessage, TranscriptionSegment, SessionModality } from '../types/core';
 import { VoxketInteractiveView, ViewPresentationMode, InteractiveUIState, RpcEvents } from '../types/rpc';
-import { WidgetTheme } from '../styles';
-import { DisplayType, PopupPosition } from '../components/widget';
-export interface RenderUIOptions {
-    target?: string | HTMLElement;
-    modality?: SessionModality[];
-    theme?: WidgetTheme | 'dark' | 'light' | 'vox';
-    component?: 'widget' | 'session' | 'chat-only' | 'voice-only';
-    className?: string;
-    style?: React.CSSProperties;
-    autoStart?: boolean;
-    agentId?: string;
-    participantName?: string;
-    displayType?: DisplayType;
-    popupPosition?: PopupPosition;
-    popupTriggerText?: string;
-    popupModalityMode?: 'all' | 'voice' | 'chat' | 'video';
-    width?: string;
-    height?: string;
-    /**
-     * Callback function to handle display type changes (e.g., when user clicks expand button).
-     * Required for expand/fullscreen functionality to work properly.
-     * @param displayType - The new display type ('widget', 'fullscreen', 'popup')
-     * @example
-     * onDisplayTypeChange: (newDisplayType) => {
-     *   console.log('Display type changed to:', newDisplayType);
-     *   // Handle the display type change in your app
-     * }
-     */
-    onDisplayTypeChange?: (displayType: DisplayType) => void;
-    prompts?: string[];
-    statusMessage?: string;
-    welcomeTitle?: string;
-    welcomeSubTitle?: string;
-    loadingText?: string;
-    /** Participant metadata to be sent with session creation */
-    participantMetadata?: Record<string, any>;
-}
 export interface VoxketClientConfig extends VoxketConfig {
     agentId?: string;
     participantName?: string;
@@ -57,34 +20,40 @@ export interface VoxketClientConfig extends VoxketConfig {
     onUserJoined?: (userId: string) => void;
     onUserLeft?: (userId: string) => void;
 }
+/**
+ * VoxketClient
+ *
+ * Main client class that orchestrates all Voxket functionality.
+ * Uses specialized managers for different concerns:
+ * - ChatManager: Chat messages and attachments
+ * - MediaManager: Camera, microphone, screen share
+ * - ConnectionManager: Room connection and participants
+ * - StreamHandlerManager: Text/byte stream handlers
+ * - UIRenderer: React UI rendering
+ * - AgentManager: Agent state and info
+ * - RpcManager: RPC method handling
+ * - PluginManager: Plugin system
+ */
 export declare class VoxketClient extends VoxketEventEmitter<VoxketEvents & RpcEvents> {
     private config;
-    private room;
     private pluginManager;
     private rpcManager;
-    private isConnected;
+    private chatManager;
+    private mediaManager;
+    private connectionManager;
+    private streamHandlerManager;
+    private uiRenderer;
+    private agentManager;
     private currentSession;
-    private connectionState;
-    private renderedComponents;
-    private textStreamHandlersRegistered;
-    private currentAgentInfo;
-    private chatMessages;
-    private activeTranscriptions;
-    private isAgentConnected;
-    private agentState;
-    private _eventEmitters;
     constructor(config: VoxketClientConfig);
+    /**
+     * Setup event listeners for various events
+     */
     private setupEventListeners;
+    /**
+     * Setup RPC event forwarding from RpcManager
+     */
     private setupRpcEventForwarding;
-    private initializeClient;
-    private setupRoomEventListeners;
-    private setupTextStreamHandlers;
-    fetchConnectionDetails(agentId?: string, participantName?: string, modalities?: SessionModality[], participantMetadata?: Record<string, any>): Promise<{
-        serverUrl: string;
-        participantToken: string;
-        voxketSessionId: string;
-        agentInfo?: AgentInfo;
-    }>;
     connect(agentId?: string, participantName?: string, modalities?: SessionModality[], participantMetadata?: Record<string, any>): Promise<{
         serverUrl: string;
         participantToken: string;
@@ -101,66 +70,15 @@ export declare class VoxketClient extends VoxketEventEmitter<VoxketEvents & RpcE
     }): Promise<VoxketSession>;
     endSession(): Promise<SessionMetrics | null>;
     getCurrentSession(): VoxketSession | null;
-    getCurrentAgentInfo(): AgentInfo | null;
-    getIsAgentConnected(): boolean;
-    /**
-     * Force mark agent as connected - useful when agent should be visible
-     * even without receiving agent_state_changed events
-     */
-    forceAgentConnected(): void;
-    getAgentState(): 'idle' | 'thinking' | 'speaking';
-    private setAgentState;
-    /**
-     * Get agent tracks from remote participants
-     */
-    getAgentAudioTrack(): {
-        source: Track.Source;
-        participant: RemoteParticipant;
-        publication: import('livekit-client').RemoteTrackPublication;
-    } | null;
-    getAgentVideoTrack(): {
-        source: Track.Source;
-        participant: RemoteParticipant;
-        publication: import('livekit-client').RemoteTrackPublication;
-    } | null;
-    /**
-     * Get all video track references (camera and screen share) from all participants
-     */
-    getVideoTrackRefs(): Array<{
-        source: Track.Source;
-        participant: any;
-        publication: any;
-    }>;
-    /**
-     * Get camera track references only
-     */
-    getCameraTrackRefs(): Array<{
-        source: Track.Source;
-        participant: any;
-        publication: any;
-    }>;
-    /**
-     * Get screen share track references only
-     */
-    getScreenShareTrackRefs(): Array<{
-        source: Track.Source;
-        participant: any;
-        publication: any;
-    }>;
-    getChatMessages(): ChatMessage[];
-    addChatMessage(message: ChatMessage): void;
-    updateChatMessage(updatedMessage: ChatMessage): void;
-    clearChatMessages(): void;
-    renderUI(options?: RenderUIOptions): void;
-    removeUI(target?: string | HTMLElement): void;
-    removeAllUI(): void;
-    private forceCleanupFullscreenOverlays;
-    private resolveTarget;
-    private getTargetKey;
+    getSessionMetrics(): SessionMetrics | null;
     sendMessage(message: string, metadata?: Record<string, any>): Promise<void>;
     sendChatMessage(message: string, metadata?: Record<string, any>): Promise<void>;
     sendAttachments(files: File[], metadata?: Record<string, any>): Promise<void>;
     sendAttachment(file: File, metadata?: Record<string, any>): Promise<void>;
+    getChatMessages(): ChatMessage[];
+    addChatMessage(message: ChatMessage): void;
+    updateChatMessage(updatedMessage: ChatMessage): void;
+    clearChatMessages(): void;
     toggleMicrophone(enabled?: boolean): Promise<void>;
     setMicrophoneEnabled(enabled: boolean): Promise<void>;
     toggleCamera(enabled?: boolean): Promise<void>;
@@ -173,8 +91,37 @@ export declare class VoxketClient extends VoxketEventEmitter<VoxketEvents & RpcE
     getVideoInputDevices(): Promise<MediaDeviceInfo[]>;
     setAudioInputDevice(deviceId: string): Promise<void>;
     setVideoInputDevice(deviceId: string): Promise<void>;
-    getLocalParticipant(): LocalParticipant | null;
-    getRemoteParticipants(): RemoteParticipant[];
+    get isMicrophoneEnabled(): boolean;
+    get isCameraEnabled(): boolean;
+    get isScreenShareEnabled(): boolean;
+    getMicrophoneTrack(): import('livekit-client').LocalTrack<import("livekit-client").Track.Kind> | null | undefined;
+    getCameraTrack(): import('livekit-client').LocalTrack<import("livekit-client").Track.Kind> | null | undefined;
+    getScreenShareTrack(): import('livekit-client').LocalTrack<import("livekit-client").Track.Kind> | null | undefined;
+    getAgentAudioTrack(): {
+        source: import("livekit-client").Track.Source;
+        participant: import('livekit-client').RemoteParticipant;
+        publication: import('livekit-client').RemoteTrackPublication;
+    } | null;
+    getAgentVideoTrack(): {
+        source: import("livekit-client").Track.Source;
+        participant: import('livekit-client').RemoteParticipant;
+        publication: import('livekit-client').RemoteTrackPublication;
+    } | null;
+    getVideoTrackRefs(): {
+        source: import("livekit-client").Track.Source;
+        participant: any;
+        publication: any;
+    }[];
+    getCameraTrackRefs(): {
+        source: import("livekit-client").Track.Source;
+        participant: any;
+        publication: any;
+    }[];
+    getScreenShareTrackRefs(): {
+        source: import("livekit-client").Track.Source;
+        participant: any;
+        publication: any;
+    }[];
     getPublishPermissions(): {
         camera: boolean;
         microphone: boolean;
@@ -182,89 +129,32 @@ export declare class VoxketClient extends VoxketEventEmitter<VoxketEvents & RpcE
         data: boolean;
     };
     canPublishSource(source: 'camera' | 'microphone' | 'screenShare'): boolean;
+    getLocalParticipant(): import('livekit-client').LocalParticipant | null;
+    getRemoteParticipants(): import('livekit-client').RemoteParticipant[];
+    getParticipants(): ParticipantInfo[];
     getRoom(): Room | null;
     getConnectionState(): ConnectionState;
     get connected(): boolean;
-    getMicrophoneTrack(): import('livekit-client').LocalTrack<Track.Kind> | null | undefined;
-    getCameraTrack(): import('livekit-client').LocalTrack<Track.Kind> | null | undefined;
-    getScreenShareTrack(): import('livekit-client').LocalTrack<Track.Kind> | null | undefined;
-    get isMicrophoneEnabled(): boolean;
-    get isCameraEnabled(): boolean;
-    get isScreenShareEnabled(): boolean;
-    registerPlugin(plugin: any): void;
-    getPluginManager(): PluginManager;
-    getParticipants(): ParticipantInfo[];
-    getSessionMetrics(): SessionMetrics | null;
-    updateConfig(updates: Partial<VoxketClientConfig>): void;
-    startRecording(): Promise<void>;
-    stopRecording(): Promise<void>;
-    /**
-     * Register a frontend RPC method with a React component
-     * @param methodName The RPC method name to register
-     * @param component React component that implements VoxketInteractiveView
-     * @param presentationMode How the component should be displayed
-     */
+    getCurrentAgentInfo(): AgentInfo | null;
+    getIsAgentConnected(): boolean;
+    getAgentState(): 'idle' | 'thinking' | 'speaking';
+    renderUI(options?: RenderUIOptions): void;
+    removeUI(target?: string | HTMLElement): void;
+    removeAllUI(): void;
     registerFrontendRPC(methodName: string, component: VoxketInteractiveView, presentationMode?: ViewPresentationMode): Promise<void>;
-    /**
-     * Get the current interactive RPC component state
-     */
     getCurrentInteraction(): InteractiveUIState | null;
-    /**
-     * Dismiss the current interactive component
-     */
     dismissCurrentInteraction(): void;
-    /**
-     * Get all registered RPC methods
-     */
     getRegisteredRpcMethods(): string[];
-    /**
-     * Unregister an RPC method
-     */
     unregisterRpcMethod(methodName: string): void;
-    /**
-     * Set participant metadata that will be sent with session creation requests.
-     * This is useful for passing business-specific user information to the API.
-     * @param metadata Object containing participant metadata (e.g., userId, customerType, etc.)
-     */
-    setParticipantMetadata(metadata: Record<string, any>): void;
-    /**
-     * Get the current participant metadata
-     */
-    getParticipantMetadata(): Record<string, any> | undefined;
-    /**
-     * Register a custom event listener for VoxketClient events.
-     * This is a business-friendly alias for the inherited `on` method.
-     * @param eventName The event name to listen for (string)
-     * @param callback The callback function to invoke with event data
-     * @returns Unsubscribe function
-     *
-     * Example:
-     *   client.registerEventListener('chat.message.received', (msg) => { ... });
-     */
+    registerPlugin(plugin: any): void;
+    getPluginManager(): PluginManager;
     registerEventListener<K extends keyof (VoxketEvents & RpcEvents)>(eventName: K, callback: (data: any) => void): () => void;
-    /**
-     * Register a custom event emitter for a LiveKit text stream topic.
-     * This allows business/consumer code to listen for custom events sent via text stream.
-     * @param topic The topic name to listen for (string)
-     * @param handler The callback function to invoke with (data, participantInfo)
-     * @returns void
-     *
-     * Example:
-     *   client.registerEventEmitter('custom_event', (data) => { ... });
-     */
     registerEventEmitter(topic: string, handler: (data: string) => void): void;
-    /**
-     * Get the list of registered custom event emitters (for debugging)
-     */
     getRegisteredEventEmitters(): string[];
-    /**
-     * Check if a custom event emitter is registered for a topic
-     */
     hasEventEmitter(topic: string): boolean;
-    /**
-     * Convert markdown text to plain text by removing common markdown formatting
-     * @param markdownText The markdown text to convert
-     * @returns Plain text without markdown formatting
-     */
-    private convertMarkdownToText;
+    updateConfig(updates: Partial<VoxketClientConfig>): void;
+    setParticipantMetadata(metadata: Record<string, any>): void;
+    getParticipantMetadata(): Record<string, any> | undefined;
+    startRecording(): Promise<void>;
+    stopRecording(): Promise<void>;
 }

package/dist/core/connection-manager.d.ts

@@ -0,0 +1,81 @@
+import { Room, ConnectionState } from 'livekit-client';
+import { VoxketEventEmitter } from './event-emitter';
+import { VoxketEvents, AgentInfo, ParticipantInfo, SessionModality } from '../types/core';
+export interface ConnectionConfig {
+    baseUrl: string;
+    appId: string;
+    appSecret: string;
+}
+/**
+ * ConnectionManager
+ *
+ * Manages all connection-related functionality including:
+ * - Room connection and disconnection
+ * - Connection state management
+ * - Participant tracking
+ * - Connection details fetching
+ * - Room event handling
+ */
+export declare class ConnectionManager {
+    private room;
+    private config;
+    private eventEmitter;
+    private connectionState;
+    private isConnected;
+    private currentAgentInfo;
+    constructor(config: ConnectionConfig, eventEmitter: VoxketEventEmitter<VoxketEvents>);
+    /**
+     * Initialize or reinitialize the room
+     */
+    private initializeRoom;
+    /**
+     * Setup event listeners for the room
+     */
+    private setupRoomEventListeners;
+    /**
+     * Fetch connection details from the server
+     */
+    fetchConnectionDetails(agentId: string, participantName: string, modalities: SessionModality[], participantMetadata?: Record<string, any>): Promise<{
+        serverUrl: string;
+        participantToken: string;
+        voxketSessionId: string;
+        agentInfo?: AgentInfo;
+    }>;
+    /**
+     * Connect to the room
+     */
+    connect(agentId: string, participantName: string, modalities: SessionModality[], participantMetadata?: Record<string, any>): Promise<{
+        serverUrl: string;
+        participantToken: string;
+        voxketSessionId: string;
+        agentInfo?: AgentInfo;
+    }>;
+    /**
+     * Disconnect from the room
+     */
+    disconnect(): Promise<void>;
+    /**
+     * Get the current room instance
+     */
+    getRoom(): Room | null;
+    /**
+     * Get the connection state
+     */
+    getConnectionState(): ConnectionState;
+    /**
+     * Check if connected
+     */
+    get connected(): boolean;
+    /**
+     * Get current agent info
+     */
+    getCurrentAgentInfo(): AgentInfo | null;
+    /**
+     * Get all participants
+     */
+    getParticipants(): ParticipantInfo[];
+    /**
+     * Update configuration
+     */
+    updateConfig(updates: Partial<ConnectionConfig>): void;
+}

package/dist/core/index.d.ts

@@ -4,6 +4,14 @@
  */
 export { VoxketClient } from './client';
 export { VoxketEventEmitter } from './event-emitter';
+export { RpcManager } from './rpc-manager';
+export { ChatManager } from './chat-manager';
+export { MediaManager } from './media-manager';
+export { ConnectionManager } from './connection-manager';
+export { StreamHandlerManager } from './stream-handler-manager';
+export { UIRenderer } from './ui-renderer';
+export { AgentManager } from './agent-manager';
 export { VoxketClient as VoxketSDK } from './client';
 export type * from '../types/core';
-export type { RenderUIOptions, VoxketClientConfig } from './client';
+export type { VoxketClientConfig } from './client';
+export type { RenderUIOptions } from './ui-renderer';

package/dist/core/media-manager.d.ts

@@ -0,0 +1,177 @@
+import { Room, LocalParticipant, RemoteParticipant, Track } from 'livekit-client';
+import { VoxketEventEmitter } from './event-emitter';
+import { VoxketEvents } from '../types/core';
+/**
+ * MediaManager
+ *
+ * Manages all media-related functionality including:
+ * - Camera control
+ * - Microphone control
+ * - Screen share control
+ * - Device enumeration
+ * - Track management
+ * - Media permissions
+ */
+export declare class MediaManager {
+    private room;
+    private eventEmitter;
+    private silencePreventionNode;
+    private silencePreventionOscillator;
+    private audioContext;
+    constructor(eventEmitter: VoxketEventEmitter<VoxketEvents>);
+    /**
+     * Initialize AudioContext and ensure it's running
+     * This must be called on user interaction to comply with browser autoplay policies
+     */
+    private initializeAudioContext;
+    /**
+     * Ensure AudioContext is running (call before any audio operations)
+     */
+    ensureAudioContextRunning(): Promise<void>;
+    /**
+     * Set the room instance for media management
+     */
+    setRoom(room: Room | null): void;
+    /**
+     * Get local participant
+     */
+    getLocalParticipant(): LocalParticipant | null;
+    /**
+     * Get remote participants
+     */
+    getRemoteParticipants(): RemoteParticipant[];
+    /**
+     * Toggle microphone (if enabled is not specified, it will toggle)
+     */
+    toggleMicrophone(enabled?: boolean): Promise<void>;
+    /**
+     * Set microphone enabled state
+     */
+    setMicrophoneEnabled(enabled: boolean): Promise<void>;
+    /**
+     * Start silence prevention by injecting a very low-volume tone
+     * This prevents LiveKit's silence detection from restarting the microphone track
+     */
+    private startSilencePrevention;
+    /**
+     * Stop silence prevention
+     */
+    private stopSilencePrevention;
+    /**
+     * Toggle camera (if enabled is not specified, it will toggle)
+     */
+    toggleCamera(enabled?: boolean): Promise<void>;
+    /**
+     * Set camera enabled state
+     */
+    setCameraEnabled(enabled: boolean): Promise<void>;
+    /**
+     * Enable camera
+     */
+    enableCamera(): Promise<void>;
+    /**
+     * Disable camera
+     */
+    disableCamera(): Promise<void>;
+    /**
+     * Start screen share
+     */
+    startScreenShare(): Promise<void>;
+    /**
+     * Stop screen share
+     */
+    stopScreenShare(): Promise<void>;
+    /**
+     * Get available audio input devices
+     */
+    getAudioInputDevices(): Promise<MediaDeviceInfo[]>;
+    /**
+     * Get available video input devices
+     */
+    getVideoInputDevices(): Promise<MediaDeviceInfo[]>;
+    /**
+     * Set audio input device
+     */
+    setAudioInputDevice(deviceId: string): Promise<void>;
+    /**
+     * Set video input device
+     */
+    setVideoInputDevice(deviceId: string): Promise<void>;
+    /**
+     * Get microphone track
+     */
+    getMicrophoneTrack(): import('livekit-client').LocalTrack<Track.Kind> | null | undefined;
+    /**
+     * Get camera track
+     */
+    getCameraTrack(): import('livekit-client').LocalTrack<Track.Kind> | null | undefined;
+    /**
+     * Get screen share track
+     */
+    getScreenShareTrack(): import('livekit-client').LocalTrack<Track.Kind> | null | undefined;
+    /**
+     * Check if microphone is enabled
+     */
+    get isMicrophoneEnabled(): boolean;
+    /**
+     * Check if camera is enabled
+     */
+    get isCameraEnabled(): boolean;
+    /**
+     * Check if screen share is enabled
+     */
+    get isScreenShareEnabled(): boolean;
+    /**
+     * Get agent audio track
+     */
+    getAgentAudioTrack(): {
+        source: Track.Source;
+        participant: RemoteParticipant;
+        publication: import('livekit-client').RemoteTrackPublication;
+    } | null;
+    /**
+     * Get agent video track
+     */
+    getAgentVideoTrack(): {
+        source: Track.Source;
+        participant: RemoteParticipant;
+        publication: import('livekit-client').RemoteTrackPublication;
+    } | null;
+    /**
+     * Get all video track refs (local and remote, camera and screen share)
+     */
+    getVideoTrackRefs(): Array<{
+        source: Track.Source;
+        participant: any;
+        publication: any;
+    }>;
+    /**
+     * Get camera track refs only
+     */
+    getCameraTrackRefs(): Array<{
+        source: Track.Source;
+        participant: any;
+        publication: any;
+    }>;
+    /**
+     * Get screen share track refs only
+     */
+    getScreenShareTrackRefs(): Array<{
+        source: Track.Source;
+        participant: any;
+        publication: any;
+    }>;
+    /**
+     * Get publish permissions for various media sources
+     */
+    getPublishPermissions(): {
+        camera: boolean;
+        microphone: boolean;
+        screenShare: boolean;
+        data: boolean;
+    };
+    /**
+     * Check if a specific source can be published
+     */
+    canPublishSource(source: 'camera' | 'microphone' | 'screenShare'): boolean;
+}

package/dist/core/stream-handler-manager.d.ts

@@ -0,0 +1,91 @@
+import { Room } from 'livekit-client';
+import { VoxketEventEmitter } from './event-emitter';
+import { ChatManager } from './chat-manager';
+import { AgentManager } from './agent-manager';
+import { VoxketEvents } from '../types/core';
+/**
+ * StreamHandlerManager
+ *
+ * Manages all text and byte stream handlers including:
+ * - Chat message streams (lk.chat)
+ * - Transcription streams (lk.transcription)
+ * - Agent state change streams
+ * - Tool execution streams
+ * - Image attachment streams
+ * - Custom event emitter streams
+ * - Suggested response streams
+ */
+export declare class StreamHandlerManager {
+    private room;
+    private eventEmitter;
+    private chatManager;
+    private agentManager;
+    private textStreamHandlersRegistered;
+    private _eventEmitters;
+    constructor(eventEmitter: VoxketEventEmitter<VoxketEvents>, chatManager: ChatManager, agentManager: AgentManager);
+    /**
+     * Set the room instance for stream handling
+     * Automatically registers handlers when room is set and not already registered
+     */
+    setRoom(room: Room | null): void;
+    /**
+     * Check if stream handlers are registered
+     */
+    areHandlersRegistered(): boolean;
+    /**
+     * Reset handlers registration flag
+     */
+    resetHandlersFlag(): void;
+    /**
+     * Setup all text stream handlers
+     */
+    setupTextStreamHandlers(): void;
+    /**
+     * Register chat message handler (lk.chat)
+     */
+    private registerChatHandler;
+    /**
+     * Register transcription handler (lk.transcription)
+     */
+    private registerTranscriptionHandler;
+    /**
+     * Register suggested response handler
+     */
+    private registerSuggestedResponseHandler;
+    /**
+     * Register agent state change handler
+     */
+    private registerAgentStateHandler;
+    /**
+     * Register function tools execution handler
+     */
+    private registerFunctionToolsHandler;
+    /**
+     * Register image text stream handler
+     */
+    private registerImageTextStreamHandler;
+    /**
+     * Register image byte stream handler
+     */
+    private registerImageByteStreamHandler;
+    /**
+     * Register handlers for common topics
+     */
+    private registerCommonTopicHandlers;
+    /**
+     * Register wildcard handler for unhandled topics
+     */
+    private registerWildcardHandler;
+    /**
+     * Register a custom event emitter for a specific topic
+     */
+    registerEventEmitter(topic: string, handler: (data: string) => void): void;
+    /**
+     * Get all registered event emitters
+     */
+    getRegisteredEventEmitters(): string[];
+    /**
+     * Check if an event emitter is registered for a topic
+     */
+    hasEventEmitter(topic: string): boolean;
+}