@hanzo/react 0.1.2 → 1.0.0

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 HanzoComponent {
+    name: string;
+    component: React$1.ComponentType<any>;
+    description?: string;
+    parameters?: z.ZodType<any>;
+    generateUI?: (params: any) => React$1.ReactElement;
+}
+interface HanzoTool {
+    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 HanzoContextValue {
+    apiKey?: string;
+    apiUrl?: string;
+    model?: string;
+    components: Map<string, HanzoComponent>;
+    tools: Map<string, HanzoTool>;
+    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: HanzoComponent) => void;
+    unregisterComponent: (name: string) => void;
+    renderComponent: (name: string, props: any) => React$1.ReactElement | null;
+    registerTool: (tool: HanzoTool) => void;
+    unregisterTool: (name: string) => void;
+    executeTool: (name: string, params: any) => Promise<any>;
+    isStreaming: boolean;
+    responseStage?: 'thinking' | 'generating' | 'tool-calling' | 'completed';
+    error?: Error;
+}
+interface HanzoProviderProps {
+    children: React$1.ReactNode;
+    apiKey?: string;
+    apiUrl?: string;
+    model?: string;
+    components?: HanzoComponent[];
+    tools?: HanzoTool[];
+    initialMessages?: Message[];
+    onMessage?: (message: Message) => void;
+    onError?: (error: Error) => void;
+    enableStreaming?: boolean;
+    enableMCP?: boolean;
+    mcpServers?: string[];
+}
+declare function HanzoProvider({ children, apiKey, apiUrl, model, components: initialComponents, tools: initialTools, initialMessages, onMessage, onError, enableStreaming, enableMCP, // eslint-disable-line @typescript-eslint/no-unused-vars
+mcpServers }: HanzoProviderProps): react_jsx_runtime.JSX.Element;
+declare function useHanzo(): HanzoContextValue;
+
+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 HanzoComponent, type HanzoContextValue, HanzoProvider, type HanzoProviderProps, type HanzoTool, 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, useHanzo, useMessage, useStreaming };