@voxket-ai/voxket-live 1.0.35 → 1.0.36

package/dist/plugins/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Plugins Export
+ * Plugin system and built-in plugins
+ */
+export * from './plugin-system';
+export * from './modalities/voice-plugin';
+export * from './modalities/chat-plugin';

package/dist/plugins/modalities/chat-plugin.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Chat Modality Plugin
+ * Enhanced chat capabilities with custom UI components
+ */
+export interface ChatPluginConfig {
+    enableRichText?: boolean;
+    enableFileUpload?: boolean;
+    enableCustomComponents?: boolean;
+    maxMessageLength?: number;
+    autoScroll?: boolean;
+}
+export declare const chatModalityPlugin: import('../plugin-system').Plugin;
+export interface ChatComponent {
+    type: string;
+    props: Record<string, any>;
+    timestamp: Date;
+}
+export interface QuickAction {
+    id: string;
+    label: string;
+    action: string;
+    variant?: 'primary' | 'secondary' | 'danger';
+}
+export interface FormField {
+    name: string;
+    type: 'text' | 'email' | 'number' | 'select' | 'textarea';
+    label: string;
+    required?: boolean;
+    options?: string[];
+    validation?: Record<string, any>;
+}

package/dist/plugins/modalities/voice-plugin.d.ts

@@ -0,0 +1,8 @@
+import { Plugin } from '../plugin-system';
+export interface VoicePluginConfig {
+    enableTranscription?: boolean;
+    enableVoiceActivation?: boolean;
+    silenceThreshold?: number;
+    language?: string;
+}
+export declare const voiceModalityPlugin: Plugin;

package/dist/plugins/plugin-system.d.ts

@@ -0,0 +1,64 @@
+import { VoxketClient } from '../core/client';
+import { VoxketEvents } from '../types/core';
+export interface PluginContext {
+    client: VoxketClient;
+    emit: <K extends keyof VoxketEvents>(event: K, ...args: Parameters<VoxketEvents[K]>) => void;
+    on: <K extends keyof VoxketEvents>(event: K, handler: VoxketEvents[K]) => () => void;
+    config: Record<string, any>;
+}
+export interface Plugin {
+    name: string;
+    version: string;
+    description?: string;
+    dependencies?: string[];
+    install?(context: PluginContext): void | Promise<void>;
+    uninstall?(context: PluginContext): void | Promise<void>;
+    onSessionStart?(context: PluginContext, sessionId: string): void | Promise<void>;
+    onSessionEnd?(context: PluginContext, sessionId: string): void | Promise<void>;
+    onAgentResponse?(context: PluginContext, response: any): void | Promise<void>;
+    config?: Record<string, any>;
+}
+export declare class PluginManager {
+    private plugins;
+    private installedPlugins;
+    private context;
+    constructor(client: VoxketClient);
+    /**
+     * Register a plugin
+     */
+    register(plugin: Plugin): void;
+    /**
+     * Install a plugin
+     */
+    install(pluginName: string, config?: Record<string, any>): Promise<void>;
+    /**
+     * Uninstall a plugin
+     */
+    uninstall(pluginName: string): Promise<void>;
+    /**
+     * Check if a plugin is installed
+     */
+    isInstalled(pluginName: string): boolean;
+    /**
+     * Get list of installed plugins
+     */
+    getInstalledPlugins(): string[];
+    /**
+     * Get list of available plugins
+     */
+    getAvailablePlugins(): string[];
+    /**
+     * Get plugin info
+     */
+    getPluginInfo(pluginName: string): Plugin | undefined;
+    private setupPluginEvents;
+}
+export declare function createPlugin(definition: Plugin): Plugin;
+export declare function createModalityPlugin(name: string, modality: string, handlers: {
+    onActivate?: (context: PluginContext) => void | Promise<void>;
+    onDeactivate?: (context: PluginContext) => void | Promise<void>;
+    onMessage?: (context: PluginContext, message: any) => void | Promise<void>;
+}): Plugin;
+export declare const analyticsPlugin: Plugin;
+export declare const debugPlugin: Plugin;
+export declare const metricsPlugin: Plugin;

package/dist/providers/voxket-provider.d.ts

@@ -0,0 +1,33 @@
+import { default as React, ReactNode } from 'react';
+import { VoxketClient } from '../core/client';
+import { VoxketConfig, VoxketSession, SessionState, SessionMetrics, VoxketError, ParticipantInfo, ChatMessage, TranscriptionSegment } from '../types/core';
+export interface VoxketContextValue {
+    client: VoxketClient | null;
+    isConnected: boolean;
+    isConnecting: boolean;
+    connectionError: VoxketError | null;
+    currentSession: VoxketSession | null;
+    sessionState: SessionState;
+    sessionMetrics: SessionMetrics | null;
+    participants: ParticipantInfo[];
+    chatMessages: ChatMessage[];
+    transcriptions: TranscriptionSegment[];
+    connect: () => Promise<void>;
+    disconnect: () => Promise<void>;
+    createSession: (agentId: string, options?: any) => Promise<VoxketSession>;
+    endSession: () => Promise<SessionMetrics | null>;
+    sendChatMessage: (message: string) => Promise<void>;
+    setMicrophoneEnabled: (enabled: boolean) => Promise<void>;
+    setCameraEnabled: (enabled: boolean) => Promise<void>;
+    startScreenShare: () => Promise<void>;
+    stopScreenShare: () => Promise<void>;
+}
+declare const VoxketContext: React.Context<VoxketContextValue | null>;
+export interface VoxketProviderProps {
+    config: VoxketConfig;
+    children: ReactNode;
+    autoConnect?: boolean;
+}
+export declare function VoxketProvider({ config, children, autoConnect }: VoxketProviderProps): import("react/jsx-runtime").JSX.Element;
+export declare function useVoxket(): VoxketContextValue;
+export { VoxketContext };

package/dist/styles.d.ts

@@ -15,6 +15,9 @@ export interface WidgetTheme {
         accent: string;
     };
     micButton: string;
+    chatButton: string;
+    videoButton: string;
+    popupTrigger: string;
     promptSlider: string;
     statusIndicator: string;
     pulseRings: {
@@ -23,8 +26,40 @@ export interface WidgetTheme {
         ring3: string;
     };
     controlBar: string;
-    chatInput: string;
+    chatInput: {
+        container: string;
+        textarea: string;
+        sendButton: string;
+        attachButton: string;
+        endButton: string;
+    };
+    chatMessage: {
+        own: string;
+        other: string;
+    };
+    chatHeader: {
+        container: string;
+        backButton: string;
+    };
     spinner: string;
+    suggestedResponse?: {
+        container: string;
+    };
+    video: {
+        container: string;
+        header: string;
+        headerButton: string;
+        statusDot: string;
+        controlsBackground: string;
+        controlEnabled: string;
+        controlDisabled: string;
+        endCall: string;
+        tile: string;
+        placeholder: string;
+        avatar: string;
+        nameOverlay: string;
+        mutedIndicator: string;
+    };
 }
 export declare const themes: Record<ThemeType, WidgetTheme>;
 export declare function getTheme(themeType: ThemeType): WidgetTheme;

package/dist/themes/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Themes Export
+ * Theme system and built-in themes
+ */
+export * from './theme-system';

package/dist/themes/theme-system.d.ts

@@ -0,0 +1,89 @@
+import { ReactNode } from 'react';
+export interface VoxketTheme {
+    name: string;
+    colors: {
+        primary: string;
+        secondary: string;
+        accent: string;
+        background: string;
+        surface: string;
+        text: {
+            primary: string;
+            secondary: string;
+            muted: string;
+            inverse: string;
+        };
+        status: {
+            success: string;
+            warning: string;
+            error: string;
+            info: string;
+        };
+        border: string;
+        shadow: string;
+    };
+    typography: {
+        fontFamily: string;
+        fontSize: {
+            xs: string;
+            sm: string;
+            md: string;
+            lg: string;
+            xl: string;
+        };
+        fontWeight: {
+            normal: number;
+            medium: number;
+            semibold: number;
+            bold: number;
+        };
+        lineHeight: {
+            tight: number;
+            normal: number;
+            relaxed: number;
+        };
+    };
+    spacing: {
+        xs: string;
+        sm: string;
+        md: string;
+        lg: string;
+        xl: string;
+    };
+    borderRadius: {
+        none: string;
+        sm: string;
+        md: string;
+        lg: string;
+        full: string;
+    };
+    shadows: {
+        sm: string;
+        md: string;
+        lg: string;
+    };
+    components?: {
+        [componentName: string]: Record<string, any>;
+    };
+}
+export declare const defaultTheme: VoxketTheme;
+export declare const darkTheme: VoxketTheme;
+export declare const enterpriseTheme: VoxketTheme;
+export interface ThemeContextValue {
+    theme: VoxketTheme;
+    setTheme: (theme: VoxketTheme | string) => void;
+    themes: Record<string, VoxketTheme>;
+    registerTheme: (theme: VoxketTheme) => void;
+}
+export declare const useTheme: () => ThemeContextValue;
+export interface ThemeProviderProps {
+    theme?: VoxketTheme | string;
+    themes?: Record<string, VoxketTheme>;
+    children: ReactNode;
+    cssVariables?: boolean;
+    className?: string;
+}
+export declare function ThemeProvider({ theme, themes: customThemes, children, cssVariables, className }: ThemeProviderProps): import("react/jsx-runtime").JSX.Element;
+export declare function flattenTheme(theme: VoxketTheme): Record<string, string>;
+export declare function createCustomTheme(baseTheme: VoxketTheme | undefined, overrides: Partial<VoxketTheme>): VoxketTheme;
+export declare function useComponentTheme(componentName: string): Record<string, any>;

package/dist/types/core.d.ts

@@ -0,0 +1,186 @@
+import { Room, RemoteParticipant, LocalParticipant, ConnectionState } from 'livekit-client';
+import { VideoTrack } from './video';
+export interface VoxketConfig {
+    /** Your Voxket App ID */
+    appId: string;
+    /** Your Voxket App Secret */
+    appSecret: string;
+    /** Base URL for Voxket API services */
+    baseUrl: string;
+    /** Environment (development, staging, production) */
+    environment?: 'development' | 'staging' | 'production';
+    /** Enable debug logging */
+    debug?: boolean;
+}
+export interface SessionConfig {
+    /** Unique identifier for the agent */
+    agentId: string;
+    /** Display name for the participant */
+    participantName?: string;
+    /** Session-specific metadata */
+    metadata?: Record<string, any>;
+    /** Session timeout in milliseconds */
+    timeout?: number;
+    /** Supported modalities for this session */
+    modalities?: SessionModality[];
+}
+export type SessionModality = 'voice' | 'video' | 'chat' | 'screen_share';
+export interface VoxketSession {
+    /** Unique session identifier */
+    id: string;
+    /** Agent identifier */
+    agentId: string;
+    /** Current session state */
+    state: SessionState;
+    /** Session start timestamp */
+    startedAt?: Date;
+    /** Session end timestamp */
+    endedAt?: Date;
+    /** Session metadata */
+    metadata: Record<string, any>;
+    /** Active modalities */
+    activeModalities: SessionModality[];
+    /** Agent information */
+    agentInfo?: AgentInfo | null;
+}
+export type SessionState = 'idle' | 'connecting' | 'connected' | 'active' | 'disconnecting' | 'disconnected' | 'error';
+export interface VoxketEvents extends Record<string, (...args: any[]) => void> {
+    'connection.connecting': () => void;
+    'connection.connected': () => void;
+    'connection.disconnected': (reason?: string) => void;
+    'connection.disconnecting': () => void;
+    'connection.error': (error: VoxketError) => void;
+    'connection.reconnecting': () => void;
+    'connection.reconnected': () => void;
+    'session.created': (session: VoxketSession) => void;
+    'session.started': (session: VoxketSession) => void;
+    'session.ended': (session: VoxketSession, metrics: SessionMetrics) => void;
+    'session.error': (error: VoxketError) => void;
+    'session.state.changed': (state: SessionState, previousState: SessionState) => void;
+    'agent.joined': (agent: AgentInfo) => void;
+    'agent.left': (agent: AgentInfo) => void;
+    'agent.speaking.started': (agent: AgentInfo) => void;
+    'agent.speaking.stopped': (agent: AgentInfo) => void;
+    'agent.response': (response: AgentResponse) => void;
+    'participant.joined': (participant: ParticipantInfo) => void;
+    'participant.left': (participant: ParticipantInfo) => void;
+    'participant.speaking.started': (participant: ParticipantInfo) => void;
+    'participant.speaking.stopped': (participant: ParticipantInfo) => void;
+    'media.track.published': (track: TrackInfo) => void;
+    'media.track.unpublished': (track: TrackInfo) => void;
+    'media.track.subscribed': (track: TrackInfo) => void;
+    'media.track.unsubscribed': (track: TrackInfo) => void;
+    'track.muted': (event: {
+        source: string;
+        enabled: boolean;
+    }) => void;
+    'track.unmuted': (event: {
+        source: string;
+        enabled: boolean;
+    }) => void;
+    'videoTrackAdded': (track: VideoTrack) => void;
+    'videoTrackRemoved': (trackId: string) => void;
+    'videoTrackUpdated': (track: VideoTrack) => void;
+    'recording.started': (event: {
+        sessionId?: string;
+        timestamp: Date;
+    }) => void;
+    'recording.stopped': (event: {
+        sessionId?: string;
+        timestamp: Date;
+    }) => void;
+    'chat.message.received': (message: ChatMessage) => void;
+    'chat.message.sent': (message: ChatMessage) => void;
+    'chat.message.updated': (message: ChatMessage) => void;
+    'transcription.received': (transcription: TranscriptionSegment) => void;
+}
+export interface AgentInfo {
+    id: string;
+    name: string;
+    avatar?: string;
+    capabilities: AgentCapability[];
+    metadata?: Record<string, any>;
+}
+export type AgentCapability = 'voice_interaction' | 'text_chat' | 'video_call' | 'screen_share' | 'file_upload' | 'custom_ui';
+export interface AgentResponse {
+    id: string;
+    type: 'text' | 'audio' | 'action' | 'ui_component';
+    content: string;
+    metadata?: Record<string, any>;
+    timestamp: Date;
+    agentId: string;
+}
+export interface ParticipantInfo {
+    id: string;
+    name: string;
+    avatar?: string;
+    isLocal: boolean;
+    metadata?: Record<string, any>;
+}
+export interface TrackInfo {
+    id: string;
+    kind: 'audio' | 'video';
+    source: 'microphone' | 'camera' | 'screen_share';
+    participantId: string;
+    isEnabled: boolean;
+    isMuted: boolean;
+}
+export interface ChatMessage {
+    id: string;
+    content: string;
+    timestamp: Date;
+    sender: {
+        id: string;
+        name: string;
+        type: 'participant' | 'agent';
+    };
+    metadata?: Record<string, any>;
+}
+export interface TranscriptionSegment {
+    id: string;
+    text: string;
+    isFinal: boolean;
+    startTime: number;
+    endTime?: number;
+    participantId: string;
+    language?: string;
+}
+export interface SessionMetrics {
+    sessionId: string;
+    duration: number;
+    participantCount: number;
+    messageCount: number;
+    audioQuality: QualityMetrics;
+    videoQuality?: QualityMetrics;
+    networkStats: NetworkStats;
+    events: SessionEvent[];
+}
+export interface QualityMetrics {
+    avgBitrate: number;
+    avgLatency: number;
+    packetLoss: number;
+    jitter: number;
+}
+export interface NetworkStats {
+    totalBytesReceived: number;
+    totalBytesSent: number;
+    connectionType: string;
+    avgRoundTripTime: number;
+}
+export interface SessionEvent {
+    type: string;
+    timestamp: Date;
+    data?: Record<string, any>;
+}
+export declare class VoxketError extends Error {
+    code: VoxketErrorCode;
+    details?: Record<string, any> | undefined;
+    constructor(message: string, code: VoxketErrorCode, details?: Record<string, any> | undefined);
+}
+export type VoxketErrorCode = 'AUTHENTICATION_FAILED' | 'CONNECTION_FAILED' | 'SESSION_NOT_FOUND' | 'AGENT_NOT_AVAILABLE' | 'PERMISSION_DENIED' | 'NETWORK_ERROR' | 'CONFIGURATION_ERROR' | 'NOT_CONNECTED' | 'RECORDING_ERROR' | 'DEVICE_ERROR' | 'INVALID_PARAMETER' | 'UNKNOWN_ERROR';
+export interface LiveKitIntegration {
+    room?: Room;
+    localParticipant?: LocalParticipant;
+    remoteParticipants: Map<string, RemoteParticipant>;
+    connectionState: ConnectionState;
+}

package/dist/types/rpc.d.ts

@@ -0,0 +1,143 @@
+import * as React from 'react';
+/**
+ * RPC Invocation data received from LiveKit
+ */
+export interface RpcInvocationData {
+    callerIdentity: string;
+    payload: string;
+    requestId?: string;
+    responseTimeout?: number;
+}
+/**
+ * Presentation modes for interactive components
+ */
+export type ViewPresentationMode = 'embedded' | 'modal' | 'fullscreen';
+/**
+ * Handler for interactive component responses
+ */
+export interface VoxketInteractiveUIHandler {
+    /**
+     * Called when user interaction is successful
+     * @param data Response data from user interaction
+     * @param successView Optional React component to show on success
+     */
+    didSuccess(data: Record<string, any>, successView?: React.ReactElement): void;
+    /**
+     * Called when user interaction fails or times out
+     * @param error Error data
+     */
+    didFail(error: Record<string, any>): void;
+    /**
+     * Dismiss the current view and send decline response to agent
+     * This notifies the agent that the user dismissed/declined the interaction
+     * and sends a structured response indicating the dismissal
+     */
+    dismissView(): void;
+    /**
+     * Called when user interaction times out
+     * @param timeoutView Optional React component to show on timeout
+     */
+    didTimeout?(timeoutView?: React.ReactElement): void;
+}
+/**
+ * Props passed to interactive components
+ */
+export interface VoxketInteractiveViewProps {
+    /**
+     * Handler for component responses
+     */
+    handler?: VoxketInteractiveUIHandler;
+    /**
+     * Load data into the component
+     * @param data JSON data from the agent
+     */
+    loadData?(data: any): Promise<void>;
+    /**
+     * Timeout for user interaction (in seconds)
+     */
+    timeout?: number;
+    /**
+     * Presentation mode
+     */
+    presentationMode?: ViewPresentationMode;
+    /**
+     * Data passed to the component from the RPC call
+     */
+    data?: any;
+    /**
+     * VoxketClient instance for sending messages and interacting with the session
+     */
+    client?: any;
+    /**
+     * Function to add a local message to the chat without sending to agent
+     */
+    addLocalMessage?: (content: string) => void;
+}
+/**
+ * Interface that interactive components must implement
+ */
+export type VoxketInteractiveView = React.ComponentType<VoxketInteractiveViewProps>;
+/**
+ * RPC Method registration
+ */
+export interface RpcMethodRegistration {
+    methodName: string;
+    component: VoxketInteractiveView;
+    presentationMode: ViewPresentationMode;
+    timeout?: number;
+}
+/**
+ * RPC Response data
+ */
+export interface RpcResponseData {
+    success: boolean;
+    data?: Record<string, any>;
+    message?: string;
+    error?: Record<string, any>;
+    timestamp: Date;
+}
+/**
+ * RPC Method handler function
+ */
+export type RpcMethodHandler = (data: RpcInvocationData) => Promise<string>;
+/**
+ * Interactive UI state
+ */
+export interface InteractiveUIState {
+    isVisible: boolean;
+    methodName: string;
+    component: VoxketInteractiveView | null;
+    presentationMode: ViewPresentationMode;
+    timeout: number;
+    data: any;
+    handler: VoxketInteractiveUIHandler | null;
+}
+/**
+ * Events related to RPC interactions
+ */
+export interface RpcEvents {
+    'rpc.method.registered': (data: {
+        methodName: string;
+    }) => void;
+    'rpc.method.called': (data: {
+        methodName: string;
+        data: RpcInvocationData;
+    }) => void;
+    'rpc.interaction.started': (data: {
+        methodName: string;
+        presentationMode: ViewPresentationMode;
+    }) => void;
+    'rpc.interaction.completed': (data: {
+        methodName: string;
+        response: RpcResponseData;
+    }) => void;
+    'rpc.interaction.timeout': (data: {
+        methodName: string;
+        response: RpcResponseData;
+    }) => void;
+    'rpc.interaction.dismissed': (data: {
+        methodName: string;
+        response: RpcResponseData;
+    }) => void;
+    [key: string]: (...args: any[]) => void;
+}