@cuekit-ai/react 1.1.0 → 1.2.0

package/dist/index.d.mts

@@ -1,6 +1,7 @@
-import React, { ReactNode } from 'react';
-
-declare const processVoice: (transcript: string, apiKey?: string, appId?: string, deviceId?: string) => Promise<any | null>;
+import * as React from 'react';
+import React__default, { ReactNode } from 'react';
+import * as livekit_client from 'livekit-client';
+import { ConnectionState, Room } from 'livekit-client';
 
 declare global {
     interface CueKitGlobalStore {
@@ -14,45 +15,361 @@ declare global {
     }
     var CuekitStore: CueKitGlobalStore;
 }
+type QubeCtx = {
+    apiKey: string;
+    appId: string;
+};
+declare const useQubeContext: () => QubeCtx;
 type Props = {
     apiKey: string;
     deviceId?: string;
     appId: string;
     children: ReactNode;
-    navigator?: any;
-};
-declare const CuekitProvider: React.FC<Props>;
-
-declare const useAudioController: () => {
-    stop: () => void;
-    isPlaying: () => boolean;
-    play: (url: string) => Promise<void>;
+    navigationHandler?: (path: string, params?: Record<string, any>) => void;
+    onConnectionStateChange?: (state: any) => void;
+    onParticipantUpdate?: (participants: string[]) => void;
+    onToolLog?: (log: any) => void;
 };
+declare const CuekitProvider: React__default.FC<Props>;
 
-declare function onStateChange(): void;
+interface CuekitConfig {
+    apiKey: string;
+    appId?: string;
+    webRTC?: {
+        serverUrl?: string;
+        roomName?: string;
+        participantName?: string;
+        tokenTtlSeconds?: number;
+    };
+}
+declare function InitCuekit(config: CuekitConfig): void;
 
 type ScreenPosition = 'bottom-center' | 'bottom-left' | 'bottom-right';
+type MicState$1 = 'idle' | 'listening' | 'thinking' | 'replying';
 type MicButtonProps = {
     hasText?: boolean;
     text?: string;
-    textStyle?: React.CSSProperties;
+    textStyle?: React__default.CSSProperties;
     imageSource?: string;
-    imageStyle?: React.CSSProperties;
-    buttonStyle?: React.CSSProperties;
+    imageStyle?: React__default.CSSProperties;
+    buttonStyle?: React__default.CSSProperties;
     screenPosition?: ScreenPosition;
     bottomSpace?: number;
     buttonSize?: number;
+    defaultTheme?: 'light' | 'dark' | 'system';
+    showBorderGlow?: boolean;
 };
 
-declare const MicButton: React.FC<MicButtonProps>;
+declare const MicButton: React__default.FC<MicButtonProps>;
+
+interface ChatPopupProps {
+    isOpen: boolean;
+    isMinimized: boolean;
+    onClose: () => void;
+    onMinimize: () => void;
+    onRestore: () => void;
+    onSendText: (text: string) => Promise<any>;
+    onEndCall?: () => Promise<void>;
+    messages: Array<{
+        text: string;
+        sender: 'user' | 'assistant';
+    }>;
+    isConnected: boolean;
+    micState: string;
+    participants: string[];
+    error?: string | null;
+    currentTheme?: 'light' | 'dark';
+    onThemeToggle?: (theme: 'light' | 'dark') => void;
+    status?: string;
+    anchor?: {
+        position: 'bottom-right' | 'bottom-left' | 'bottom-center';
+        bottom: number;
+        size: number;
+    };
+}
+declare const ChatPopup: React__default.FC<ChatPopupProps>;
+
+interface BorderGlowProps {
+    isActive: boolean;
+}
+declare const BorderGlow: ({ isActive }: BorderGlowProps) => React__default.JSX.Element | null;
 
-declare function InitCuekit(apiKey: string, navigator?: any): void;
+interface VoiceIntensityVisualizerProps {
+    isActive: boolean;
+    barCount?: number;
+    minHeight?: number;
+    className?: string;
+    buttonSize?: number;
+}
+declare const VoiceIntensityVisualizer: React__default.FC<VoiceIntensityVisualizerProps>;
 
-declare const useVoiceRecognition: (lang?: string) => {
-    isListening: boolean;
-    startListening: () => Promise<string>;
-    stopListening: () => Promise<void>;
-    speechText: string;
+interface AuthResponse {
+    session_id: string;
+    api_key: string;
+    user_identity: string;
+    app_id: string;
+    livekit_url: string;
+    livekit_token: string;
+    room_name: string;
+}
+interface TokenRequest {
+    user_identity: string;
+    room_name: string;
+    ttl_seconds: number;
+}
+interface TokenResponse {
+    token: string;
+    room_name: string;
+    expires_in: number;
+}
+interface ServerConfig {
+    livekit_url: string;
+    room_name: string;
+    participant_name: string;
+    token_ttl_seconds: number;
+    server_version: string;
+}
+interface NavigationCommand {
+    type: 'static_data_ready' | 'ai_intent' | 'user_speech_text' | 'ai_speech_text';
+    data?: {
+        app_id?: string;
+        components?: any[];
+        intents?: any[];
+        pages_count?: number;
+        elements_count?: number;
+    };
+    intent?: string;
+    actionType?: string;
+    text?: string;
+    confidence?: number;
+    target_element?: string;
+    current_page?: string;
+    user_input?: string;
+    speaker?: 'user' | 'ai';
+    duration?: number;
+    timestamp?: number;
+}
+declare function sendData(data: any, reliable?: boolean): Promise<void>;
+declare function sendScreenStatus(screenData: any): Promise<void>;
+declare function sendUserCommand(command: string): Promise<void>;
+declare function sendStaticData(componentData: any, appId?: string): Promise<{
+    success: boolean;
+    data: any;
+    error?: undefined;
+} | {
+    success: boolean;
+    error: string;
+    data?: undefined;
+}>;
+
+interface UserSpeechChunkData {
+    text_chunk: string;
+    is_final: boolean;
+}
+interface AISpeechChunkData {
+    text_chunk: string;
+    is_final: boolean;
+}
+interface AIIntentData {
+    intent: string;
+    routeName: string | null;
+    actionType: string;
+    confidence: number;
+    actionMetadata: {
+        elementId: string | null;
+        routeName: string | null;
+    };
+}
+interface AIInterruptedData {
+    message: string;
+}
+interface RequestRuntimeData {
+    session_id: string;
+}
+interface StaticDataReadyData {
+    [key: string]: any;
+}
+interface ToolLogData {
+    [key: string]: any;
+}
+type SSEActionEvent = {
+    type: 'user_speech_chunk';
+    timestamp?: number;
+    data: UserSpeechChunkData;
+} | {
+    type: 'ai_speech_chunk';
+    timestamp?: number;
+    data: AISpeechChunkData;
+} | {
+    type: 'ai_intent';
+    timestamp?: number;
+    data: AIIntentData;
+} | {
+    type: 'ai_interrupted';
+    timestamp?: number;
+    data: AIInterruptedData;
+} | {
+    type: 'request_runtime_data';
+    timestamp?: number;
+    data: RequestRuntimeData;
+} | {
+    type: 'static_data_ready';
+    data: StaticDataReadyData;
+} | {
+    type: 'tool_log';
+    data: ToolLogData;
+} | {
+    type: 'connection';
+    status: 'connected';
+    app_id?: string;
+} | {
+    type: 'keepalive';
+    timestamp?: number;
 };
+interface SSEServiceCallbacks {
+    onActionEvent?: (event: SSEActionEvent) => void;
+    onConnectionChange?: (isConnected: boolean) => void;
+    onConversationUpdate?: (entry: {
+        speaker: 'user' | 'ai';
+        text: string;
+        is_final: boolean;
+    }) => void;
+    onIntentUpdate?: (intent: AIIntentData) => void;
+    onToolStatusUpdate?: (status: any) => void;
+    onStaticDataUpdate?: (data: any) => void;
+    onError?: (error: string) => void;
+}
+declare function setSSECallbacks(newCallbacks: SSEServiceCallbacks): void;
+declare function connectSSE(newSessionId: string): Promise<void>;
+declare function sendRuntimeData(): Promise<void>;
+declare function sendDashboardData(dashboardData: any): Promise<void>;
+declare function sendElementData(appId?: string): Promise<{
+    app_id: string;
+    current_page: string;
+    dom_structure: FullDOMStructure;
+    timestamp: number;
+}>;
+declare function disconnectSSE(): void;
+declare function getSSEConnectionStatus(): boolean;
+declare function getSSEConnectionState(): string;
+
+interface ChatMessage {
+    id: string;
+    role: 'user' | 'ai';
+    text: string;
+    isFinal: boolean;
+    timestamp: string;
+}
+type MicState = 'idle' | 'listening' | 'thinking' | 'replying';
+declare const useCuekit: (options?: {
+    onNavigationCommand?: (command: NavigationCommand) => void;
+    onConnectionStateChange?: (state: ConnectionState) => void;
+    onParticipantUpdate?: (participants: string[]) => void;
+    onAISpeechStart?: (trackId: string) => void;
+    onAISpeechEnd?: (trackId: string) => void;
+    appId?: string;
+}) => {
+    isSseConnected: boolean;
+    lastActionEvent: SSEActionEvent | null;
+    messages: ChatMessage[];
+    micState: MicState;
+    setMicState: React.Dispatch<React.SetStateAction<MicState>>;
+    status: string;
+    setStatus: React.Dispatch<React.SetStateAction<string>>;
+    connect: (identity: string, apiKey?: string, appId?: string) => Promise<void>;
+    disconnect: () => Promise<void>;
+    isConnected: boolean;
+    isConnecting: boolean;
+    connectionState: ConnectionState | null;
+    room: livekit_client.Room | null;
+    roomName: string | null;
+    participants: string[];
+    error: string | null;
+    sendData: typeof sendData;
+    sendScreenStatus: typeof sendScreenStatus;
+    sendUserCommand: typeof sendUserCommand;
+    sendStaticData: typeof sendStaticData;
+    audioContainerRef: React.RefObject<HTMLDivElement>;
+};
+
+declare const useWebRTC: (options?: {
+    onNavigationCommand?: (command: NavigationCommand) => void;
+    onConnectionStateChange?: (state: ConnectionState) => void;
+    onParticipantUpdate?: (participants: string[]) => void;
+    onAISpeechStart?: (trackId: string) => void;
+    onAISpeechEnd?: (trackId: string) => void;
+    autoConnect?: boolean;
+    userIdentity?: string;
+    appId?: string;
+}) => {
+    isConnected: boolean;
+    isConnecting: boolean;
+    connectionState: ConnectionState | null;
+    room: Room | null;
+    roomName: string | null;
+    participants: string[];
+    error: string | null;
+    connect: (identity: string, apiKey?: string, appId?: string) => Promise<AuthResponse | undefined>;
+    disconnect: () => Promise<void>;
+    sendData: typeof sendData;
+    sendScreenStatus: typeof sendScreenStatus;
+    sendUserCommand: typeof sendUserCommand;
+    sendStaticData: typeof sendStaticData;
+    audioContainerRef: React.RefObject<HTMLDivElement>;
+};
+
+interface WebRTCServerConfig {
+    serverUrl?: string;
+    apiKey: string;
+    roomName?: string;
+    participantName?: string;
+    tokenTtlSeconds?: number;
+}
+/**
+ * Configure WebRTC server settings
+ * @param config WebRTC server configuration (API key is required, others are optional)
+ */
+declare const configureWebRTCServer: (config: WebRTCServerConfig) => void;
+/**
+ * Get the current WebRTC server configuration
+ */
+declare const getWebRTCServerConfig: () => WebRTCServerConfig | null;
+/**
+ * Initialize WebRTC with API key (server URL uses default)
+ * @param apiKey Your API key for the WebRTC server
+ * @param customConfig Optional custom configuration overrides
+ */
+declare const initWebRTCWithDeployedBackend: (apiKey: string, customConfig?: Partial<Omit<WebRTCServerConfig, "apiKey">>) => WebRTCServerConfig;
+/**
+ * Initialize WebRTC with minimal configuration (requires API key)
+ * This is the simplest way to get started
+ * @param apiKey Your API key for the WebRTC server
+ */
+declare const initWebRTC: (apiKey: string) => WebRTCServerConfig;
+
+type DOMNodeData = {
+    hash: string;
+    text: string;
+    isClickable: boolean;
+    componentType: string;
+    children: DOMNodeData[];
+};
+type FullDOMStructure = {
+    components: DOMNodeData[];
+};
+
+interface ElementAction {
+    action_type: 'click' | 'navigate' | 'input' | 'focus' | 'toggle';
+    target_element?: string;
+    target?: string;
+    instruction?: string;
+}
+declare function executeAction(action: ElementAction): boolean;
+declare function getFullDOMStructure(): FullDOMStructure;
+
+/**
+ * Capture the full DOM structure as a flat list of interactive elements
+ */
+declare function captureFullDOMStructure(): FullDOMStructure;
 
-export { CuekitProvider, InitCuekit, MicButton, onStateChange, processVoice, useAudioController, useVoiceRecognition };
+export { BorderGlow, ChatPopup, type ChatPopupProps, CuekitProvider, type DOMNodeData, type ElementAction, type FullDOMStructure, InitCuekit, MicButton, type MicButtonProps, type MicState$1 as MicState, type NavigationCommand, type SSEActionEvent, type SSEServiceCallbacks, type ServerConfig, type TokenRequest, type TokenResponse, VoiceIntensityVisualizer, type WebRTCServerConfig, captureFullDOMStructure, configureWebRTCServer, connectSSE, disconnectSSE, executeAction, getFullDOMStructure, getSSEConnectionState, getSSEConnectionStatus, getWebRTCServerConfig, initWebRTC, initWebRTCWithDeployedBackend, sendDashboardData, sendElementData, sendRuntimeData, setSSECallbacks, useCuekit, useQubeContext, useWebRTC };