@libreapps/react 1.1.1

package/dist/index.d.ts

@@ -0,0 +1,255 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import React$1 from 'react';
+import { z } from 'zod';
+import { ClassValue } from 'clsx';
+
+interface LibreAppsComponent {
+    name: string;
+    component: React$1.ComponentType<any>;
+    description?: string;
+    parameters?: z.ZodType<any>;
+    generateUI?: (params: any) => React$1.ReactElement;
+}
+interface LibreAppsTool {
+    name: string;
+    description: string;
+    parameters: z.ZodType<any>;
+    execute: (params: any) => Promise<any>;
+}
+interface Message {
+    id: string;
+    role: 'user' | 'assistant' | 'system' | 'tool';
+    content: string | React$1.ReactElement;
+    timestamp: Date;
+    threadId: string;
+    toolCalls?: ToolCall[];
+    metadata?: Record<string, any>;
+}
+interface ToolCall {
+    id: string;
+    name: string;
+    arguments: any;
+    result?: any;
+    status: 'pending' | 'running' | 'completed' | 'failed';
+}
+interface Thread {
+    id: string;
+    messages: Message[];
+    createdAt: Date;
+    updatedAt: Date;
+    metadata?: Record<string, any>;
+}
+interface LibreAppsContextValue {
+    apiKey?: string;
+    apiUrl?: string;
+    model?: string;
+    components: Map<string, LibreAppsComponent>;
+    tools: Map<string, LibreAppsTool>;
+    threads: Map<string, Thread>;
+    activeThreadId?: string;
+    sendMessage: (content: string, threadId?: string) => Promise<Message>;
+    streamMessage: (content: string, threadId?: string) => AsyncGenerator<Message>;
+    createThread: (metadata?: Record<string, any>) => Thread;
+    switchThread: (threadId: string) => void;
+    deleteThread: (threadId: string) => void;
+    registerComponent: (component: LibreAppsComponent) => void;
+    unregisterComponent: (name: string) => void;
+    renderComponent: (name: string, props: any) => React$1.ReactElement | null;
+    registerTool: (tool: LibreAppsTool) => void;
+    unregisterTool: (name: string) => void;
+    executeTool: (name: string, params: any) => Promise<any>;
+    isStreaming: boolean;
+    responseStage?: 'thinking' | 'generating' | 'tool-calling' | 'completed';
+    error?: Error;
+}
+interface LibreAppsProviderProps {
+    children: React$1.ReactNode;
+    apiKey?: string;
+    apiUrl?: string;
+    model?: string;
+    components?: LibreAppsComponent[];
+    tools?: LibreAppsTool[];
+    initialMessages?: Message[];
+    onMessage?: (message: Message) => void;
+    onError?: (error: Error) => void;
+    enableStreaming?: boolean;
+    enableMCP?: boolean;
+    mcpServers?: string[];
+}
+declare function LibreAppsProvider({ children, apiKey, apiUrl, model, components: initialComponents, tools: initialTools, initialMessages, onMessage, onError, enableStreaming, enableMCP, // eslint-disable-line @typescript-eslint/no-unused-vars
+mcpServers }: LibreAppsProviderProps): react_jsx_runtime.JSX.Element;
+declare function useLibreApps(): LibreAppsContextValue;
+
+interface UseMessageOptions {
+    threadId?: string;
+    onSuccess?: (message: Message) => void;
+    onError?: (error: Error) => void;
+    autoRetry?: boolean;
+    maxRetries?: number;
+    retryDelay?: number;
+}
+interface UseMessageReturn {
+    sendMessage: (content: string) => Promise<Message>;
+    sendMessageWithAttachments: (content: string, attachments: File[]) => Promise<Message>;
+    isLoading: boolean;
+    error: Error | null;
+    lastMessage: Message | null;
+    clearError: () => void;
+    retry: () => Promise<void>;
+}
+declare function useMessage(options?: UseMessageOptions): UseMessageReturn;
+
+interface UseStreamingOptions {
+    threadId?: string;
+    onChunk?: (chunk: string) => void;
+    onComplete?: (message: Message) => void;
+    onError?: (error: Error) => void;
+    bufferSize?: number;
+    throttleMs?: number;
+}
+interface UseStreamingReturn {
+    streamMessage: (content: string) => Promise<void>;
+    isStreaming: boolean;
+    currentMessage: string;
+    error: Error | null;
+    stopStreaming: () => void;
+    clearMessage: () => void;
+    progress: number;
+}
+declare function useStreaming(options?: UseStreamingOptions): UseStreamingReturn;
+
+declare function cn(...inputs: ClassValue[]): string;
+
+declare function generateId(prefix?: string): string;
+
+declare function parseStream(stream: ReadableStream<Uint8Array>): Promise<string>;
+
+interface UseThreadOptions {
+    maxThreads?: number;
+    autoArchive?: boolean;
+}
+interface UseThreadReturn {
+    threads: Map<string, any>;
+    activeThread: any | undefined;
+    createThread: (metadata?: Record<string, any>) => any;
+    switchThread: (threadId: string) => void;
+    deleteThread: (threadId: string) => void;
+    updateThreadMetadata: (threadId: string, metadata: Record<string, any>) => void;
+    getThreadMessages: (threadId: string) => any[];
+    clearThread: (threadId: string) => void;
+}
+interface UseComponentOptions {
+    lazy?: boolean;
+}
+interface UseComponentReturn {
+    registerComponent: (component: any) => void;
+    unregisterComponent: (name: string) => void;
+    renderComponent: (name: string, props: any) => React.ReactElement | null;
+    getComponent: (name: string) => any | undefined;
+    hasComponent: (name: string) => boolean;
+    listComponents: () => string[];
+}
+interface UseToolOptions {
+    timeout?: number;
+}
+interface UseToolReturn {
+    executeTool: (name: string, params: any) => Promise<any>;
+    registerTool: (tool: any) => void;
+    unregisterTool: (name: string) => void;
+    isExecuting: boolean;
+    lastResult: any | null;
+    error: Error | null;
+}
+interface UseSuggestionsOptions {
+    maxSuggestions?: number;
+    autoRefresh?: boolean;
+    refreshInterval?: number;
+}
+interface UseSuggestionsReturn {
+    suggestions: any[];
+    getSuggestions: (options?: any) => Promise<void>;
+    acceptSuggestion: (suggestion: any) => void;
+    dismissSuggestion: (id: string) => void;
+    isLoading: boolean;
+}
+interface UseModelConfigOptions {
+    defaultModel?: string;
+}
+interface UseModelConfigReturn {
+    currentModel: string;
+    availableModels: any[];
+    switchModel: (modelId: string) => void;
+    updateParameters: (params: any) => void;
+    resetToDefaults: () => void;
+}
+interface UseMCPOptions {
+    autoConnect?: boolean;
+}
+interface UseMCPReturn {
+    connectServer: (config: any) => Promise<void>;
+    disconnectServer: (id: string) => void;
+    connectedServers: any[];
+    executeServerTool: (serverId: string, tool: string, params: any) => Promise<any>;
+    getServerResources: (serverId: string) => any[];
+    isConnected: (serverId: string) => boolean;
+}
+interface UseGenerativeUIOptions {
+    cacheResults?: boolean;
+}
+interface UseGenerativeUIReturn {
+    generateUI: (options: any) => Promise<React.ReactElement>;
+    isGenerating: boolean;
+    generatedComponents: React.ReactElement[];
+    clearComponents: () => void;
+    saveComponent: (name: string, component: React.ReactElement) => void;
+}
+interface UseAuthOptions {
+    provider?: string;
+}
+interface UseAuthReturn {
+    user: any | null;
+    isAuthenticated: boolean;
+    isLoading: boolean;
+    signIn: (options?: any) => Promise<void>;
+    signOut: () => Promise<void>;
+    getToken: () => Promise<string | null>;
+    refreshToken: () => Promise<void>;
+}
+interface UseAttachmentsOptions {
+    maxSize?: number;
+    allowedTypes?: string[];
+    autoUpload?: boolean;
+}
+interface UseAttachmentsReturn {
+    attachments: any[];
+    addAttachment: (file: File) => Promise<any>;
+    removeAttachment: (id: string) => void;
+    clearAttachments: () => void;
+    uploadAttachment: (attachment: any) => Promise<void>;
+    isUploading: boolean;
+    uploadProgress: number;
+}
+
+interface Suggestion {
+    id: string;
+    text: string;
+    metadata?: Record<string, any>;
+}
+interface Model {
+    id: string;
+    name: string;
+    description: string;
+    parameters?: Record<string, any>;
+}
+interface Attachment {
+    id: string;
+    name: string;
+    size: number;
+    type: string;
+    url?: string;
+    file?: File;
+}
+
+declare const VERSION = "1.0.0";
+
+export { type Attachment, type LibreAppsComponent, type LibreAppsContextValue, LibreAppsProvider, type LibreAppsProviderProps, type LibreAppsTool, type Message, type Model, type Suggestion, type Thread, type ToolCall, type UseAttachmentsOptions, type UseAttachmentsReturn, type UseAuthOptions, type UseAuthReturn, type UseComponentOptions, type UseComponentReturn, type UseGenerativeUIOptions, type UseGenerativeUIReturn, type UseMCPOptions, type UseMCPReturn, type UseMessageOptions, type UseMessageReturn, type UseModelConfigOptions, type UseModelConfigReturn, type UseStreamingOptions, type UseStreamingReturn, type UseSuggestionsOptions, type UseSuggestionsReturn, type UseThreadOptions, type UseThreadReturn, type UseToolOptions, type UseToolReturn, VERSION, cn, generateId, parseStream, useLibreApps, useMessage, useStreaming };