@meetsmore-oss/use-ai-client 1.2.1

package/dist/index.d.ts

@@ -0,0 +1,1953 @@
+import { z } from 'zod';
+export { z } from 'zod';
+import * as _meetsmore_oss_use_ai_core from '@meetsmore-oss/use-ai-core';
+import { ToolDefinition, WorkflowStatus, AgentInfo, McpHeadersMap, MultimodalContent, AGUIEvent, Message as Message$1, UseAIClientMessage } from '@meetsmore-oss/use-ai-core';
+export { AgentInfo, ToolDefinition } from '@meetsmore-oss/use-ai-core';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import React$1, { ReactNode } from 'react';
+
+/**
+ * Options for configuring tool behavior.
+ */
+interface ToolOptions {
+    /** Whether the tool asks the AI for explicit user confirmation before execution */
+    confirmationRequired?: boolean;
+}
+/**
+ * JSON Schema representation type (simplified)
+ */
+interface JSONSchema {
+    type?: string;
+    properties?: Record<string, unknown>;
+    required?: string[];
+    additionalProperties?: boolean | Record<string, unknown>;
+    [key: string]: unknown;
+}
+/**
+ * A tool definition with validation schema and execution function.
+ * Created by the `defineTool` function and used to define tools that the AI can call.
+ *
+ * @template T - The Zod schema type for validating tool input
+ */
+interface DefinedTool<T extends z.ZodType> {
+    /** Human-readable description of what the tool does */
+    description: string;
+    /** JSON Schema representation of the input schema */
+    _jsonSchema: JSONSchema;
+    /** Zod schema for validating input */
+    _zodSchema: T;
+    /** The function to execute when the tool is called */
+    fn: (input: z.infer<T>) => unknown | Promise<unknown>;
+    /** Configuration options for the tool */
+    _options: ToolOptions;
+    /** Converts this tool to a ToolDefinition for registration with the server */
+    _toToolDefinition: (name: string) => ToolDefinition;
+    /** Validates input and executes the tool function */
+    _execute: (input: unknown) => Promise<unknown>;
+}
+/**
+ * Defines a tool with no input parameters that can be called by the AI.
+ *
+ * @template TReturn - The return type of the tool function
+ * @param description - Human-readable description of what the tool does
+ * @param fn - The function to execute when the tool is called
+ * @param options - Optional configuration for the tool
+ * @returns A DefinedTool that can be registered with useAI
+ *
+ * @example
+ * ```typescript
+ * const getCurrentTime = defineTool(
+ *   'Get the current time',
+ *   () => new Date().toISOString()
+ * );
+ * ```
+ */
+declare function defineTool<TReturn>(description: string, fn: () => TReturn | Promise<TReturn>, options?: ToolOptions): DefinedTool<z.ZodObject<{}>>;
+/**
+ * Defines a tool with typed input parameters that can be called by the AI.
+ *
+ * @template TSchema - The Zod schema type for validating input
+ * @param description - Human-readable description of what the tool does
+ * @param schema - Zod schema defining the tool's input parameters
+ * @param fn - The function to execute when the tool is called
+ * @param options - Optional configuration for the tool
+ * @returns A DefinedTool that can be registered with useAI
+ *
+ * @example
+ * ```typescript
+ * import { defineTool } from '@meetsmore-oss/use-ai-client';
+ * import { z } from 'zod';
+ *
+ * const addTodo = defineTool(
+ *   'Add a new todo item',
+ *   z.object({ text: z.string() }),
+ *   (input) => {
+ *     todos.push({ id: Date.now(), text: input.text, completed: false });
+ *     return { success: true };
+ *   }
+ * );
+ * ```
+ */
+declare function defineTool<TSchema extends z.ZodType>(description: string, schema: TSchema, fn: (input: z.infer<TSchema>) => unknown | Promise<unknown>, options?: ToolOptions): DefinedTool<TSchema>;
+/**
+ * A collection of named tools.
+ * Used to register multiple tools with the useAI hook.
+ */
+type ToolsDefinition = Record<string, DefinedTool<z.ZodType>>;
+/**
+ * Converts a ToolsDefinition to an array of ToolDefinition objects.
+ *
+ * @param tools - The tools to convert
+ * @returns Array of tool definitions suitable for server registration
+ * @internal
+ */
+declare function convertToolsToDefinitions(tools: ToolsDefinition): ToolDefinition[];
+/**
+ * Executes a defined tool by name with the provided input.
+ *
+ * @param tools - The collection of available tools
+ * @param toolName - The name of the tool to execute
+ * @param input - The input parameters for the tool
+ * @returns The result of executing the tool
+ * @throws Error if the tool is not found
+ * @internal
+ */
+declare function executeDefinedTool(tools: ToolsDefinition, toolName: string, input: unknown): Promise<unknown>;
+
+/**
+ * Options for configuring the useAI hook.
+ */
+interface UseAIOptions {
+    /** Tools to make available to the AI for this component */
+    tools?: ToolsDefinition;
+    /** Callback function invoked when an error occurs */
+    onError?: (error: Error) => void;
+    /** Optional ID for namespacing tools to avoid naming conflicts */
+    id?: string;
+    /** Optional UI context or description to send to the AI */
+    prompt?: string;
+    /**
+     * Mark this component as invisible (no visual state).
+     * When true, tool responses are sent immediately without waiting for prompt changes.
+     * Use this for provider-type components that expose tools but don't render UI.
+     * @default false
+     */
+    invisible?: boolean;
+    /**
+     * Optional array of suggestion strings to display as call-to-action prompts
+     * when the chat is empty. The chat UI will randomly select up to 4 suggestions
+     * to display to the user.
+     */
+    suggestions?: string[];
+    /**
+     * Whether the AI features are enabled for this hook.
+     * When false, tools are not registered and the hook returns a disabled state.
+     * Useful for feature flagging AI functionality.
+     * @default true
+     */
+    enabled?: boolean;
+}
+/**
+ * Return value from the useAI hook.
+ */
+interface UseAIResult {
+    /** The AI's response text, or null if no response yet */
+    response: string | null;
+    /** Whether the AI is currently processing a request */
+    loading: boolean;
+    /** Error object if an error occurred, or null */
+    error: Error | null;
+    /** Function to send a prompt to the AI */
+    generate: (prompt: string) => Promise<void>;
+    /** Whether the client is connected to the server */
+    connected: boolean;
+    /** Ref to attach to the component for context extraction */
+    ref: React.RefObject<HTMLDivElement>;
+}
+/**
+ * React hook for integrating AI capabilities into a component.
+ * Registers tools with the AI server and provides methods to interact with the AI.
+ */
+declare function useAI(options?: UseAIOptions): UseAIResult;
+
+/**
+ * TODO: We would prefer to have this in a separate package, but it creates bundling problems with shared react contexts.
+ */
+
+/**
+ * Progress update from a workflow execution.
+ */
+interface WorkflowProgress {
+    /** Current status of the workflow */
+    status: WorkflowStatus;
+    /** Text output from the workflow (if any) */
+    text?: string;
+    /** Error message (if status is 'error') */
+    error?: string;
+    /** Tool calls made during workflow execution */
+    toolCalls?: Array<{
+        toolName: string;
+        args: Record<string, unknown>;
+        result?: unknown;
+    }>;
+}
+/**
+ * Configuration for triggering a workflow.
+ */
+interface TriggerWorkflowOptions {
+    /** Input data for the workflow */
+    inputs: Record<string, any>;
+    /** Optional tools that the workflow can call */
+    tools?: ToolsDefinition;
+    /** Optional callback for progress updates */
+    onProgress?: (progress: WorkflowProgress) => void;
+    /** Optional callback when workflow completes successfully */
+    onComplete?: (result: any) => void;
+    /** Optional callback when workflow encounters an error */
+    onError?: (error: Error) => void;
+}
+/**
+ * Result from the useAIWorkflow hook.
+ */
+interface UseAIWorkflowResult {
+    /** Triggers a workflow execution */
+    trigger: (options: TriggerWorkflowOptions) => Promise<void>;
+    /** Current status of the workflow */
+    status: WorkflowStatus;
+    /** Accumulated text output from the workflow */
+    text: string | null;
+    /** Error if workflow failed */
+    error: Error | null;
+    /** Whether the client is connected to the server */
+    connected: boolean;
+}
+/**
+ * React hook for triggering headless workflows.
+ *
+ * Workflows are different from chat-based agents:
+ * - No conversation history (stateless)
+ * - No chat UI involvement
+ * - Can use external platforms (Dify, Flowise, etc.)
+ * - Still supports tool calls to frontend
+ *
+ * Use this for button-triggered operations like:
+ * - File upload processing
+ * - Data transformations
+ * - Multi-step background tasks
+ * - External workflow integrations
+ *
+ * @param runner - The runner to use (e.g., 'dify', 'flowise', 'claude')
+ * @param workflowId - The workflow identifier
+ *
+ * @example
+ * ```typescript
+ * import { useAIWorkflow } from '@meetsmore-oss/use-ai-plugin-workflows-client';
+ * import { defineTool, z } from '@meetsmore-oss/use-ai-client';
+ *
+ * function PDFUploadButton() {
+ *   const { trigger, status, text } = useAIWorkflow('dify', 'pdf-processor');
+ *
+ *   const insertText = defineTool(
+ *     'Insert text into the document',
+ *     z.object({ text: z.string() }),
+ *     (input) => {
+ *       document.body.appendChild(document.createTextNode(input.text));
+ *       return { success: true };
+ *     }
+ *   );
+ *
+ *   const handleUpload = async (file: File) => {
+ *     const pdfData = await file.arrayBuffer();
+ *
+ *     await trigger({
+ *       inputs: { file: pdfData },
+ *       tools: { insertText },
+ *       onProgress: (progress) => console.log('Progress:', progress),
+ *       onComplete: (result) => console.log('Completed:', result),
+ *       onError: (error) => console.error('Error:', error),
+ *     });
+ *   };
+ *
+ *   return (
+ *     <div>
+ *       <input type="file" onChange={(e) => handleUpload(e.target.files[0])} />
+ *       {status === 'running' && <p>Processing...</p>}
+ *       {status === 'completed' && <p>Done! {text}</p>}
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+declare function useAIWorkflow(runner: string, workflowId: string): UseAIWorkflowResult;
+
+/**
+ * Configuration for the UseAI client provider.
+ */
+interface UseAIConfig {
+    /** The WebSocket URL of the UseAI server */
+    serverUrl: string;
+}
+
+/**
+ * Default maximum file size (10MB)
+ */
+declare const DEFAULT_MAX_FILE_SIZE: number;
+/**
+ * Persisted file metadata (lightweight, for storage).
+ * Only metadata is stored - not the actual file data.
+ */
+interface PersistedFileMetadata {
+    /** Original file name */
+    name: string;
+    /** File size in bytes */
+    size: number;
+    /** MIME type of the file */
+    mimeType: string;
+}
+/**
+ * Runtime file attachment (local File reference until send).
+ * The File object is kept in memory until the message is sent,
+ * at which point it's converted to a URL via the FileUploadBackend.
+ */
+interface FileAttachment {
+    /** Unique identifier for this attachment */
+    id: string;
+    /** The local File object */
+    file: File;
+    /** Data URL for image thumbnails (generated on attach for preview) */
+    preview?: string;
+}
+/**
+ * Abstract file upload backend interface.
+ * Converts File objects to URLs at send time.
+ *
+ * Implementations:
+ * - EmbedFileUploadBackend: Converts to base64 data URL (built-in)
+ * - S3FileUploadBackend: Uploads to S3 and returns public URL (future)
+ */
+interface FileUploadBackend {
+    /**
+     * Prepare file for sending to AI.
+     * Called at send time - converts File to URL.
+     *
+     * @param file - The File object to prepare
+     * @returns Promise resolving to a URL string
+     *          - For embed: base64 data URL
+     *          - For S3: public URL after upload
+     */
+    prepareForSend(file: File): Promise<string>;
+}
+/**
+ * Configuration for file uploads in UseAIProvider.
+ */
+interface FileUploadConfig {
+    /**
+     * Backend for converting files to URLs at send time.
+     * Defaults to EmbedFileUploadBackend if not specified.
+     */
+    backend?: FileUploadBackend;
+    /**
+     * Maximum file size in bytes.
+     * @default 10485760 (10MB)
+     */
+    maxFileSize?: number;
+    /**
+     * Accepted MIME types.
+     * Supports patterns like 'image/*' or specific types like 'application/pdf'.
+     * If undefined, all types are accepted.
+     */
+    acceptedTypes?: string[];
+}
+
+/**
+ * Display mode for chat messages.
+ * Determines the visual styling of the message bubble.
+ */
+type MessageDisplayMode$1 = 'default' | 'error';
+/**
+ * Text content part for persisted messages.
+ */
+interface PersistedTextContent {
+    type: 'text';
+    text: string;
+}
+/**
+ * File content part for persisted messages.
+ * Only stores metadata, not the actual file data.
+ */
+interface PersistedFileContent {
+    type: 'file';
+    file: PersistedFileMetadata;
+}
+/**
+ * Content part for persisted messages.
+ * Can be text or file metadata.
+ */
+type PersistedContentPart = PersistedTextContent | PersistedFileContent;
+/**
+ * Content that can be persisted.
+ * Simple string for text-only messages, or array for multimodal content.
+ */
+type PersistedMessageContent = string | PersistedContentPart[];
+/**
+ * Message format for persisted chat history.
+ * Compatible with AI SDK's UIMessage format for future integration.
+ */
+interface PersistedMessage {
+    id: string;
+    role: 'user' | 'assistant' | 'tool';
+    /** Content can be a string or multimodal content array */
+    content: PersistedMessageContent;
+    createdAt: Date;
+    displayMode?: MessageDisplayMode$1;
+}
+/**
+ * Represents a stored chat conversation.
+ */
+interface Chat {
+    id: string;
+    title?: string;
+    messages: PersistedMessage[];
+    createdAt: Date;
+    updatedAt: Date;
+}
+/**
+ * Options for creating a new chat.
+ */
+interface CreateChatOptions {
+    title?: string;
+}
+/**
+ * Options for listing chats.
+ */
+interface ListChatsOptions {
+    limit?: number;
+    offset?: number;
+}
+/**
+ * Abstract repository interface for chat persistence.
+ * Implementations can store chats locally (localStorage, IndexedDB)
+ * or remotely (REST API, GraphQL, etc.)
+ */
+interface ChatRepository {
+    /**
+     * Creates a new chat and returns its ID.
+     * @param options Optional configuration for the new chat
+     * @returns Promise resolving to the new chat ID
+     */
+    createChat(options?: CreateChatOptions): Promise<string>;
+    /**
+     * Loads a chat by ID.
+     * @param id Chat ID to load
+     * @returns Promise resolving to the chat, or null if not found
+     */
+    loadChat(id: string): Promise<Chat | null>;
+    /**
+     * Saves or updates a chat.
+     * @param chat Chat to save
+     * @returns Promise resolving when save is complete
+     */
+    saveChat(chat: Chat): Promise<void>;
+    /**
+     * Deletes a chat by ID.
+     * @param id Chat ID to delete
+     * @returns Promise resolving when deletion is complete
+     */
+    deleteChat(id: string): Promise<void>;
+    /**
+     * Lists all available chats (metadata only, without full message history).
+     * @param options Optional pagination and filtering options
+     * @returns Promise resolving to array of chat metadata
+     */
+    listChats(options?: ListChatsOptions): Promise<Array<Omit<Chat, 'messages'>>>;
+    /**
+     * Deletes all stored chats.
+     * @returns Promise resolving when all chats are deleted
+     */
+    deleteAll(): Promise<void>;
+}
+/**
+ * Generates a unique chat ID.
+ */
+declare function generateChatId(): string;
+/**
+ * Generates a unique message ID.
+ */
+declare function generateMessageId(): string;
+
+/**
+ * A saved slash command.
+ */
+interface SavedCommand {
+    /** Unique identifier */
+    id: string;
+    /** Command name (without the leading slash) */
+    name: string;
+    /** The saved text */
+    text: string;
+    /** When the command was created */
+    createdAt: Date;
+    /** When the command was last used */
+    lastUsedAt?: Date;
+}
+/**
+ * Options for creating a command.
+ */
+interface CreateCommandOptions {
+    name: string;
+    text: string;
+}
+/**
+ * Options for listing commands.
+ */
+interface ListCommandsOptions {
+    /** Filter commands by name prefix */
+    namePrefix?: string;
+    /** Limit number of results */
+    limit?: number;
+}
+/**
+ * Abstract repository interface for command persistence.
+ */
+interface CommandRepository {
+    createCommand(options: CreateCommandOptions): Promise<string>;
+    loadCommand(id: string): Promise<SavedCommand | null>;
+    loadCommandByName(name: string): Promise<SavedCommand | null>;
+    updateCommand(command: SavedCommand): Promise<void>;
+    deleteCommand(id: string): Promise<void>;
+    listCommands(options?: ListCommandsOptions): Promise<SavedCommand[]>;
+    deleteAll(): Promise<void>;
+}
+/**
+ * Generates a unique command ID.
+ */
+declare function generateCommandId(): string;
+/**
+ * Validates a command name.
+ * Commands must be kebab-case: lowercase letters, numbers, and hyphens only.
+ * Returns null if valid, or an error message if invalid.
+ */
+declare function validateCommandName(name: string): string | null;
+
+/**
+ * Default text labels for the chat UI.
+ * Use for internationalization (i18n) or branding.
+ */
+declare const defaultStrings: {
+    header: {
+        /** Header title when no chat history feature */
+        aiAssistant: string;
+        /** Label for new chat button tooltip */
+        newChat: string;
+        /** Delete chat confirmation message */
+        deleteConfirm: string;
+        /** Delete button tooltip */
+        deleteChat: string;
+        /** Connection status: online */
+        online: string;
+        /** Connection status: offline */
+        offline: string;
+    };
+    chatHistory: {
+        /** Chat history: no chats message */
+        noChatHistory: string;
+        /** Chat history: active chat indicator */
+        active: string;
+    };
+    emptyChat: {
+        /** Empty chat welcome message */
+        startConversation: string;
+        /** Empty chat help text */
+        askMeToHelp: string;
+    };
+    input: {
+        /** Input placeholder when connected */
+        placeholder: string;
+        /** Input placeholder when connecting */
+        connectingPlaceholder: string;
+        /** Send button text */
+        send: string;
+        /** Loading indicator text */
+        thinking: string;
+    };
+    fileUpload: {
+        /** Attach files button tooltip */
+        attachFiles: string;
+        /** Drop zone text when dragging files */
+        dropFilesHere: string;
+        /** File size error (use {filename} and {maxSize} placeholders) */
+        fileSizeError: string;
+        /** File type error (use {type} placeholder) */
+        fileTypeError: string;
+    };
+    floatingButton: {
+        /** Floating button title when connected */
+        openAssistant: string;
+        /** Floating button title when connecting */
+        connectingToAssistant: string;
+    };
+    commands: {
+        /** No saved commands empty state */
+        noSavedCommands: string;
+        /** No matching commands message */
+        noMatchingCommands: string;
+        /** Delete command button tooltip */
+        deleteCommand: string;
+        /** Command name input placeholder */
+        commandNamePlaceholder: string;
+        /** Save command button tooltip */
+        saveCommand: string;
+        /** Error when command name already exists */
+        commandNameExists: string;
+        /** Error when rename is not supported */
+        renameNotSupported: string;
+        /** Error when save is not supported */
+        saveNotSupported: string;
+        /** Error when rename fails */
+        renameFailed: string;
+        /** Error when save fails */
+        saveFailed: string;
+    };
+    errors: {
+        /** Error when AI service is overloaded */
+        API_OVERLOADED: string;
+        /** Error when rate limited */
+        RATE_LIMITED: string;
+        /** Error for unknown/unexpected errors */
+        UNKNOWN_ERROR: string;
+    };
+};
+/**
+ * Customizable text labels for the chat UI.
+ */
+type UseAIStrings = typeof defaultStrings;
+/**
+ * Hook to access the current strings.
+ * Returns the strings from UseAIProvider, or defaults if not inside a provider.
+ *
+ * @example
+ * ```tsx
+ * function MyComponent() {
+ *   const strings = useStrings();
+ *   return <button>{strings.input.send}</button>;
+ * }
+ * ```
+ */
+declare function useStrings(): UseAIStrings;
+
+/**
+ * Default theme configuration for the chat UI.
+ * All colors support CSS color values (hex, rgb, hsl, gradients, etc.)
+ */
+declare const defaultTheme: {
+    /** Primary color for buttons, links, active states */
+    primaryColor: string;
+    /** Primary gradient for user messages and buttons */
+    primaryGradient: string;
+    /** Translucent primary color for overlays (e.g., drop zone) */
+    primaryColorTranslucent: string;
+    /** Panel background color */
+    backgroundColor: string;
+    /** Assistant message bubble background */
+    assistantMessageBackground: string;
+    /** Hover background for buttons and items */
+    hoverBackground: string;
+    /** Active/selected item background */
+    activeBackground: string;
+    /** Disabled button background */
+    buttonDisabledBackground: string;
+    /** Primary text color */
+    textColor: string;
+    /** Secondary/muted text color */
+    secondaryTextColor: string;
+    /** Placeholder text color */
+    placeholderTextColor: string;
+    /** Online status indicator color */
+    onlineColor: string;
+    /** Offline status indicator color */
+    offlineColor: string;
+    /** Unread notification indicator color */
+    unreadIndicatorColor: string;
+    /** Error message background */
+    errorBackground: string;
+    /** Error message text color */
+    errorTextColor: string;
+    /** Danger/destructive action color (e.g., delete) */
+    dangerColor: string;
+    /** Border color for dividers and inputs */
+    borderColor: string;
+    /** Dashed border color (e.g., file placeholder) */
+    dashedBorderColor: string;
+    /** Panel box shadow */
+    panelShadow: string;
+    /** Dropdown box shadow */
+    dropdownShadow: string;
+    /** Button box shadow */
+    buttonShadow: string;
+    /** Button hover box shadow */
+    buttonHoverShadow: string;
+    /** Font family */
+    fontFamily: string;
+    /** Modal backdrop color */
+    backdropColor: string;
+};
+/**
+ * Theme configuration for the chat UI.
+ */
+type UseAITheme = typeof defaultTheme;
+/**
+ * Hook to access the current theme.
+ * Returns the theme from UseAIProvider, or defaults if not inside a provider.
+ *
+ * @example
+ * ```tsx
+ * function MyComponent() {
+ *   const theme = useTheme();
+ *   return <div style={{ color: theme.primaryColor }}>Hello</div>;
+ * }
+ * ```
+ */
+declare function useTheme(): UseAITheme;
+
+type UseAIChatPanelStrings = UseAIStrings;
+type UseAIChatPanelTheme = UseAITheme;
+/**
+ * Display mode for chat messages.
+ */
+type MessageDisplayMode = 'default' | 'error';
+/**
+ * Represents a single message in the AI conversation.
+ */
+interface Message {
+    /** Unique identifier for the message */
+    id: string;
+    /** The role of the message sender */
+    role: 'user' | 'assistant';
+    /** The message content - string or multimodal content */
+    content: PersistedMessageContent;
+    /** When the message was created */
+    timestamp: Date;
+    /** Display mode for styling the message bubble */
+    displayMode?: MessageDisplayMode;
+}
+/**
+ * Props for the chat panel component.
+ */
+interface UseAIChatPanelProps {
+    onSendMessage: (message: string, attachments?: FileAttachment[]) => void;
+    messages: Message[];
+    loading: boolean;
+    connected: boolean;
+    /** Currently streaming text from assistant (real-time updates) */
+    streamingText?: string;
+    currentChatId?: string | null;
+    onNewChat?: () => Promise<string | void>;
+    onLoadChat?: (chatId: string) => Promise<void>;
+    onDeleteChat?: (chatId: string) => Promise<void>;
+    onListChats?: () => Promise<Array<Omit<Chat, 'messages'>>>;
+    suggestions?: string[];
+    availableAgents?: AgentInfo[];
+    defaultAgent?: string | null;
+    selectedAgent?: string | null;
+    onAgentChange?: (agentId: string | null) => void;
+    fileUploadConfig?: FileUploadConfig;
+    commands?: SavedCommand[];
+    onSaveCommand?: (name: string, text: string) => Promise<string>;
+    onRenameCommand?: (id: string, newName: string) => Promise<void>;
+    onDeleteCommand?: (id: string) => Promise<void>;
+    /** Optional close button to render in header (for floating mode) */
+    closeButton?: React$1.ReactNode;
+}
+/**
+ * Chat panel content - fills its container.
+ * Use directly for embedded mode, or wrap with UseAIFloatingChatWrapper for floating mode.
+ */
+declare function UseAIChatPanel({ onSendMessage, messages, loading, connected, streamingText, currentChatId, onNewChat, onLoadChat, onDeleteChat, onListChats, suggestions, availableAgents, defaultAgent, selectedAgent, onAgentChange, fileUploadConfig, commands, onSaveCommand, onRenameCommand, onDeleteCommand, closeButton, }: UseAIChatPanelProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * Handler for AG-UI events from the server.
+ */
+type AGUIEventHandler = (event: AGUIEvent) => void;
+/**
+ * Simplified message handler for text responses.
+ */
+type MessageHandler = (content: string) => void;
+/**
+ * Tool call handler that receives the tool name, arguments, and a callback to send the result.
+ */
+type ToolCallHandler = (toolCallId: string, toolName: string, args: Record<string, unknown>) => void;
+/**
+ * Socket.IO client for communicating with the UseAI server.
+ * Uses the AG-UI protocol (https://docs.ag-ui.com/), so will be compatible with other AG-UI compliant servers.
+ *
+ * Handles:
+ * - Connection management and automatic reconnection
+ * - Sending RunAgentInput messages to server
+ * - Parsing AG-UI event streams from server
+ * - Tool execution coordination
+ *
+ * You probably don't need to use this directly, instead use {@link UseAIProvider}.
+ */
+declare class UseAIClient {
+    private serverUrl;
+    private socket;
+    private eventHandlers;
+    private reconnectAttempts;
+    private maxReconnectAttempts;
+    private reconnectDelay;
+    private _threadId;
+    private _tools;
+    private _messages;
+    private _state;
+    private mcpHeadersProvider?;
+    private _availableAgents;
+    private _defaultAgent;
+    private _selectedAgent;
+    private agentsChangeHandlers;
+    private connectionStateHandlers;
+    private _currentMessageId;
+    private _currentMessageContent;
+    private _currentAssistantMessage;
+    private _currentAssistantToolCalls;
+    private currentToolCalls;
+    /**
+     * Creates a new UseAI client instance.
+     *
+     * @param serverUrl - The WebSocket URL of the UseAI server
+     */
+    constructor(serverUrl: string);
+    /**
+     * Establishes a Socket.IO connection to the server.
+     * Connection state changes are notified via onConnectionStateChange().
+     * Socket.IO handles reconnection automatically.
+     */
+    connect(): void;
+    private handleEvent;
+    /**
+     * Registers available tools and optional state with the server.
+     * This updates the session state for future agent runs.
+     *
+     * @param tools - Array of tool definitions to register
+     * @param state - Optional state object to provide to the AI.
+     */
+    registerTools(tools: ToolDefinition[], state?: unknown): void;
+    /**
+     * Updates the state without re-registering tools.
+     * Call this before sendPrompt to ensure the AI sees the latest UI state.
+     *
+     * @param state - The current state object to provide to the AI
+     */
+    updateState(state: unknown): void;
+    /**
+     * Sets the MCP headers provider.
+     * The provider will be called each time a message is sent to get fresh headers.
+     *
+     * @param provider - Function that returns MCP headers configuration
+     */
+    setMcpHeadersProvider(provider: () => McpHeadersMap | Promise<McpHeadersMap>): void;
+    /**
+     * Sends a user prompt to the AI.
+     *
+     * @param prompt - The user's prompt/question (text part)
+     * @param multimodalContent - Optional multimodal content (text, images, files)
+     */
+    sendPrompt(prompt: string, multimodalContent?: MultimodalContent[]): Promise<void>;
+    /**
+     * Sends the result of a tool execution back to the server.
+     *
+     * @param toolCallId - The ID of the tool call being responded to
+     * @param result - The result returned by the tool execution
+     * @param state - Optional updated state to send back to the AI
+     */
+    sendToolResponse(toolCallId: string, result: unknown, state?: unknown): void;
+    /**
+     * Retrieves accumulated tool call data for a specific tool call ID.
+     * Used to get the complete tool name and arguments after they've been streamed
+     * across multiple TOOL_CALL_ARGS events.
+     *
+     * @param toolCallId - The ID of the tool call
+     * @returns Object with tool name and accumulated arguments, or undefined if not found
+     */
+    getToolCallData(toolCallId: string): {
+        name: string;
+        args: string;
+    } | undefined;
+    /**
+     * Registers an AG-UI event handler for receiving server events.
+     *
+     * @param id - Unique identifier for this handler
+     * @param handler - Callback function to handle incoming AG-UI events
+     * @returns Cleanup function to unregister the handler
+     */
+    onEvent(id: string, handler: AGUIEventHandler): () => void;
+    /**
+     * Helper method to listen for text message content.
+     * Aggregates TEXT_MESSAGE_CONTENT events and calls handler with complete messages.
+     *
+     * @param handler - Callback function to handle complete text messages
+     * @returns Cleanup function
+     */
+    onTextMessage(handler: MessageHandler): () => void;
+    /**
+     * Helper method to listen for tool call requests.
+     * Aggregates TOOL_CALL_* events and calls handler with complete tool calls.
+     *
+     * @param handler - Callback function to handle tool calls
+     * @returns Cleanup function
+     */
+    onToolCall(handler: ToolCallHandler): () => void;
+    /**
+     * Gets the current accumulated message content (useful during streaming).
+     */
+    get currentMessageContent(): string;
+    /**
+     * Gets the current thread ID for this session.
+     * Generates a new one if not set.
+     */
+    get threadId(): string;
+    /**
+     * Gets the current conversation messages.
+     */
+    get messages(): Message$1[];
+    /**
+     * Gets the current state.
+     */
+    get state(): unknown;
+    /**
+     * Gets the list of available agents from the server.
+     */
+    get availableAgents(): AgentInfo[];
+    /**
+     * Gets the default agent ID from the server.
+     */
+    get defaultAgent(): string | null;
+    /**
+     * Gets the currently selected agent ID.
+     * Returns null if using server default.
+     */
+    get selectedAgent(): string | null;
+    /**
+     * Gets the effective agent ID (selected or default).
+     */
+    get currentAgent(): string | null;
+    /**
+     * Sets the agent to use for requests.
+     * Pass null to use the server default.
+     *
+     * @param agentId - The agent ID to use, or null for server default
+     */
+    setAgent(agentId: string | null): void;
+    /**
+     * Subscribes to agent changes (when server sends available agents).
+     *
+     * @param handler - Callback function receiving agents list and default agent
+     * @returns Cleanup function to unsubscribe
+     */
+    onAgentsChange(handler: (agents: AgentInfo[], defaultAgent: string | null) => void): () => void;
+    /**
+     * Subscribes to connection state changes.
+     * This is called on both initial connection and reconnection.
+     *
+     * @param handler - Callback function receiving connection state (true = connected, false = disconnected)
+     * @returns Cleanup function to unsubscribe
+     */
+    onConnectionStateChange(handler: (connected: boolean) => void): () => void;
+    /**
+     * Sets the thread ID for this session.
+     * When the thread ID changes, conversation state is cleared to prevent history bleeding.
+     * Use this when switching between different chat conversations.
+     *
+     * @param threadId - The thread/chat ID to use (typically the chatId)
+     */
+    setThreadId(threadId: string): void;
+    /**
+     * Loads messages into the conversation history (for resuming from storage).
+     * @param messages - Array of messages to load
+     */
+    loadMessages(messages: Message$1[]): void;
+    /**
+     * Clears the conversation history and resets the thread.
+     */
+    clearConversation(): void;
+    send(message: UseAIClientMessage): void;
+    /**
+     * Closes the Socket.IO connection to the server.
+     */
+    disconnect(): void;
+    /**
+     * Checks if the client is currently connected to the server.
+     *
+     * @returns true if connected, false otherwise
+     */
+    isConnected(): boolean;
+}
+
+/**
+ * Chat management context (from useChatManagement hook).
+ */
+interface ChatContextValue {
+    /** The current chat ID */
+    currentId: string | null;
+    /** Creates a new chat and switches to it */
+    create: () => Promise<string>;
+    /** Loads an existing chat by ID */
+    load: (chatId: string) => Promise<void>;
+    /** Deletes a chat by ID */
+    delete: (chatId: string) => Promise<void>;
+    /** Lists all available chats */
+    list: () => Promise<Array<Omit<Chat, 'messages'>>>;
+    /** Clears the current chat messages */
+    clear: () => Promise<void>;
+}
+/**
+ * Agent selection context (from useAgentSelection hook).
+ */
+interface AgentContextValue {
+    /** List of available agents from the server */
+    available: AgentInfo[];
+    /** The default agent ID from the server */
+    default: string | null;
+    /** The currently selected agent ID (null means use server default) */
+    selected: string | null;
+    /** Sets the agent to use for requests */
+    set: (agentId: string | null) => void;
+}
+/**
+ * Command management context (from useCommandManagement hook).
+ */
+interface CommandContextValue {
+    /** List of saved slash commands */
+    list: SavedCommand[];
+    /** Refreshes the commands list from storage */
+    refresh: () => Promise<void>;
+    /** Saves a new command */
+    save: (name: string, text: string) => Promise<string>;
+    /** Renames an existing command */
+    rename: (id: string, newName: string) => Promise<void>;
+    /** Deletes a command by ID */
+    delete: (id: string) => Promise<void>;
+}
+/**
+ * Tool registry context (from useToolRegistry hook).
+ */
+interface ToolRegistryContextValue {
+    /** Registers tools for a specific component */
+    register: (id: string, tools: ToolsDefinition, options?: {
+        invisible?: boolean;
+    }) => void;
+    /** Unregisters tools for a specific component */
+    unregister: (id: string) => void;
+}
+/**
+ * Prompt management context.
+ */
+interface PromptsContextValue {
+    /** Updates the prompt and suggestions for a specific component */
+    update: (id: string, prompt?: string, suggestions?: string[]) => void;
+    /** Registers a waiter function for a component */
+    registerWaiter: (id: string, waiter: () => Promise<void>) => void;
+    /** Unregisters a waiter function */
+    unregisterWaiter: (id: string) => void;
+}
+/**
+ * Context value provided by UseAIProvider.
+ * Contains connection state and methods for managing tools and prompts.
+ */
+interface UseAIContextValue {
+    /** The WebSocket URL of the UseAI server */
+    serverUrl: string;
+    /** Whether the client is connected to the server */
+    connected: boolean;
+    /** The underlying WebSocket client instance */
+    client: UseAIClient | null;
+    /** Tool registry (from useToolRegistry hook) */
+    tools: ToolRegistryContextValue;
+    /** Prompt management */
+    prompts: PromptsContextValue;
+    /** Chat management (from useChatManagement hook) */
+    chat: ChatContextValue;
+    /** Agent selection (from useAgentSelection hook) */
+    agents: AgentContextValue;
+    /** Command management (from useCommandManagement hook) */
+    commands: CommandContextValue;
+}
+/**
+ * Props for custom floating button component.
+ * Used to customize the appearance and behavior of the AI chat trigger button.
+ */
+interface FloatingButtonProps {
+    /** Callback when the button is clicked */
+    onClick: () => void;
+    /** Whether the client is connected to the server */
+    connected: boolean;
+    /** Whether there are unread messages */
+    hasUnread?: boolean;
+}
+/**
+ * Props for custom chat panel component.
+ * Used to customize the appearance and behavior of the AI chat interface.
+ */
+interface ChatPanelProps {
+    /** Whether the chat panel is open */
+    isOpen: boolean;
+    /** Callback when the panel should close */
+    onClose: () => void;
+    /** Callback when a message is sent */
+    onSendMessage: (message: string) => void;
+    /** Array of messages in the conversation */
+    messages: Message[];
+    /** Whether the AI is currently processing */
+    loading: boolean;
+    /** Whether the client is connected to the server */
+    connected: boolean;
+    /** Optional array of suggestion strings to display when chat is empty */
+    suggestions?: string[];
+    /** List of available agents from the server */
+    availableAgents?: AgentInfo[];
+    /** The default agent ID from the server */
+    defaultAgent?: string | null;
+    /** The currently selected agent ID */
+    selectedAgent?: string | null;
+    /** Callback when agent is changed */
+    onAgentChange?: (agentId: string | null) => void;
+}
+interface UseAIProviderProps extends UseAIConfig {
+    children: ReactNode;
+    systemPrompt?: string;
+    CustomButton?: React$1.ComponentType<FloatingButtonProps> | null;
+    CustomChat?: React$1.ComponentType<ChatPanelProps> | null;
+    /**
+     * Custom chat repository for message persistence.
+     * Defaults to LocalStorageChatRepository if not provided.
+     */
+    chatRepository?: ChatRepository;
+    /**
+     * Callback to provide HTTP headers for MCP endpoints.
+     * Called each time AI is invoked by use-ai.
+     * Returns a mapping of MCP endpoint patterns to header configurations.
+     *
+     * Patterns can be:
+     * - Constant strings: `https://api.example.com` - Exact match
+     * - Glob patterns: `https://*.meetsmore.com` - Wildcard matching using picomatch
+     *
+     * @example
+     * ```typescript
+     * mcpHeadersProvider={() => ({
+     *   // Exact match
+     *   'https://api.example.com': {
+     *     headers: { 'Authorization': `Bearer ${userToken}` }
+     *   },
+     *   // Wildcard subdomain
+     *   'https://*.meetsmore.com': {
+     *     headers: { 'X-API-Key': apiKey }
+     *   },
+     *   // Multiple wildcards
+     *   '*://*.example.com': {
+     *     headers: { 'X-Custom': 'value' }
+     *   }
+     * })}
+     * ```
+     */
+    mcpHeadersProvider?: () => _meetsmore_oss_use_ai_core.McpHeadersMap | Promise<_meetsmore_oss_use_ai_core.McpHeadersMap>;
+    /**
+     * Configuration for file uploads.
+     * File upload is enabled by default with EmbedFileUploadBackend, 10MB max size,
+     * and accepts images and PDFs.
+     *
+     * Set to `false` to disable file uploads.
+     *
+     * @default { backend: EmbedFileUploadBackend, maxFileSize: 10MB, acceptedTypes: ['image/*', 'application/pdf'] }
+     *
+     * @example
+     * ```typescript
+     * // Custom config
+     * fileUploadConfig={{
+     *   backend: new EmbedFileUploadBackend(),
+     *   maxFileSize: 5 * 1024 * 1024, // 5MB
+     *   acceptedTypes: ['image/*'],
+     * }}
+     *
+     * // Disable file uploads
+     * fileUploadConfig={false}
+     * ```
+     */
+    fileUploadConfig?: FileUploadConfig | false;
+    /**
+     * Custom command repository for slash command persistence.
+     * Defaults to LocalStorageCommandRepository if not provided.
+     */
+    commandRepository?: CommandRepository;
+    /**
+     * Whether to render the built-in chat UI (floating button + panel).
+     * Set to false when using the `<UseAIChat>` component to control chat placement.
+     * @default true
+     */
+    renderChat?: boolean;
+    /**
+     * Custom theme for all chat UI components.
+     * Partial allows overriding only specific values.
+     */
+    theme?: Partial<UseAITheme>;
+    /**
+     * Custom strings for all chat UI components.
+     * Useful for internationalization (i18n) or branding.
+     * Partial allows overriding only specific strings.
+     */
+    strings?: Partial<UseAIStrings>;
+    /**
+     * List of agent IDs to show in the UI.
+     * When provided, only agents with these IDs will be shown (if they exist on the server).
+     *
+     * @example
+     * ```typescript
+     * <UseAIProvider
+     *   serverUrl="wss://your-server.com"
+     *   visibleAgentIds={['claude-sonnet', 'claude-opus']}
+     * >
+     *   <App />
+     * </UseAIProvider>
+     * ```
+     */
+    visibleAgentIds?: AgentInfo['id'][];
+}
+/**
+ * Provider component that manages AI client connection and tool registration.
+ * Must wrap all components that use the useAI hook.
+ *
+ * Features:
+ * - Establishes and maintains WebSocket connection to UseAI server
+ * - Aggregates tools from all child useAI hooks
+ * - Handles tool execution requests from the AI
+ * - Provides floating button and chat panel UI
+ *
+ * @param props - Provider configuration and children
+ *
+ * @example
+ * ```typescript
+ * import { UseAIProvider } from '@meetsmore-oss/use-ai-client';
+ *
+ * function App() {
+ *   return (
+ *     <UseAIProvider
+ *       serverUrl="wss://your-server.com"
+ *       systemPrompt="You are a helpful assistant for managing todos"
+ *     >
+ *       <YourApp />
+ *     </UseAIProvider>
+ *   );
+ * }
+ * ```
+ */
+declare function UseAIProvider({ serverUrl, children, systemPrompt, CustomButton, CustomChat, chatRepository, mcpHeadersProvider, fileUploadConfig: fileUploadConfigProp, commandRepository, renderChat, theme: customTheme, strings: customStrings, visibleAgentIds, }: UseAIProviderProps): react_jsx_runtime.JSX.Element;
+/**
+ * Hook to access the UseAI context.
+ * When used outside a UseAIProvider, returns a no-op context and logs a warning.
+ * This allows components with useAI hooks to render even when UseAIProvider
+ * is conditionally not rendered (e.g., feature flagged).
+ *
+ * @returns The UseAI context value (or no-op if provider is missing)
+ *
+ * @example
+ * ```typescript
+ * function MyComponent() {
+ *   const { connected, client } = useAIContext();
+ *   return <div>Connected: {connected}</div>;
+ * }
+ * ```
+ */
+declare function useAIContext(): UseAIContextValue;
+
+/**
+ * Props for the floating chat wrapper.
+ */
+interface UseAIFloatingChatWrapperProps {
+    isOpen: boolean;
+    onClose: () => void;
+    children: React$1.ReactNode;
+}
+/**
+ * Wrapper that adds floating chrome (backdrop, positioning, animations).
+ * Wrap UseAIChatPanel with this for a floating chat experience.
+ */
+declare function UseAIFloatingChatWrapper({ isOpen, onClose, children, }: UseAIFloatingChatWrapperProps): react_jsx_runtime.JSX.Element | null;
+interface CloseButtonProps {
+    onClick: () => void;
+}
+/**
+ * Close button component for the floating chat header.
+ */
+declare function CloseButton({ onClick }: CloseButtonProps): react_jsx_runtime.JSX.Element;
+
+interface UseAIFloatingButtonProps {
+    onClick: () => void;
+    connected: boolean;
+    hasUnread?: boolean;
+}
+declare function UseAIFloatingButton({ onClick, connected, hasUnread, }: UseAIFloatingButtonProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * Props for UseAIChat component.
+ */
+interface UseAIChatProps {
+    /**
+     * When true, renders as a floating panel with backdrop.
+     * When false (default), renders inline filling its container.
+     */
+    floating?: boolean;
+}
+/**
+ * Standalone chat component that can be placed anywhere within UseAIProvider.
+ *
+ * Use this when you want to control where the chat UI is rendered,
+ * such as embedding it in a sidebar or specific container.
+ *
+ * @example
+ * ```tsx
+ * // Embedded in a sidebar
+ * <UseAIProvider serverUrl="ws://localhost:8081" renderChat={false}>
+ *   <div style={{ display: 'flex', height: '100vh' }}>
+ *     <MainContent style={{ flex: 1 }} />
+ *     <aside style={{ width: 380 }}>
+ *       <UseAIChat />
+ *     </aside>
+ *   </div>
+ * </UseAIProvider>
+ *
+ * // Floating mode (manually controlled)
+ * <UseAIProvider serverUrl="ws://localhost:8081" renderChat={false}>
+ *   <App />
+ *   <UseAIChat floating />
+ * </UseAIProvider>
+ * ```
+ */
+declare function UseAIChat({ floating }: UseAIChatProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * LocalStorage-based implementation of ChatRepository.
+ * Stores chats in browser `localStorage`.
+ *
+ * Storage structure:
+ * - `use-ai:chat-index`: Array of chat IDs
+ * - `use-ai:chat:{id}`: Individual chat data
+ *
+ * Storage limit: Only the most recent 20 chats are kept by default.
+ * When creating a new chat, the oldest chat (by updatedAt) is automatically deleted if the limit is reached.
+ *
+ * @example
+ * ```typescript
+ * // Use default 20-chat limit
+ * const repository = new LocalStorageChatRepository();
+ *
+ * // Customize max chats limit
+ * const repository = new LocalStorageChatRepository(localStorage, 50);
+ * ```
+ */
+declare class LocalStorageChatRepository implements ChatRepository {
+    private storage;
+    private maxChats;
+    /**
+     * Creates a new LocalStorageChatRepository.
+     *
+     * @param storage - Storage implementation to use (defaults to browser `localStorage`)
+     * @param maxChats - Maximum number of chats to keep (defaults to 20). Oldest chats are automatically deleted when this limit is exceeded.
+     */
+    constructor(storage?: Storage, maxChats?: number);
+    createChat(options?: CreateChatOptions): Promise<string>;
+    loadChat(id: string): Promise<Chat | null>;
+    saveChat(chat: Chat): Promise<void>;
+    deleteChat(id: string): Promise<void>;
+    listChats(options?: ListChatsOptions): Promise<Array<Omit<Chat, 'messages'>>>;
+    deleteAll(): Promise<void>;
+    private getChatKey;
+    private getIndex;
+    private addToIndex;
+    private removeFromIndex;
+    private enforceMaxChatsLimit;
+}
+
+/**
+ * File upload backend that embeds files as base64 data URLs.
+ *
+ * This is the default backend for file uploads. It converts files
+ * to base64 data URLs at send time, which are then embedded directly
+ * in the message sent to the AI.
+ *
+ * Pros:
+ * - No external storage required
+ * - Simple setup
+ *
+ * Cons:
+ * - Increases message size (base64 is ~33% larger than binary)
+ * - Files are not persistent across sessions
+ * - Not suitable for very large files
+ *
+ * @example
+ * ```typescript
+ * import { UseAIProvider, EmbedFileUploadBackend } from '@meetsmore-oss/use-ai-client';
+ *
+ * <UseAIProvider
+ *   serverUrl="wss://..."
+ *   fileUploadConfig={{
+ *     backend: new EmbedFileUploadBackend(),
+ *     maxFileSize: 10 * 1024 * 1024, // 10MB
+ *   }}
+ * >
+ *   <App />
+ * </UseAIProvider>
+ * ```
+ */
+declare class EmbedFileUploadBackend implements FileUploadBackend {
+    /**
+     * Converts a File to a base64 data URL.
+     *
+     * @param file - The File object to convert
+     * @returns Promise resolving to a base64 data URL (e.g., "data:image/png;base64,...")
+     * @throws Error if file reading fails
+     */
+    prepareForSend(file: File): Promise<string>;
+}
+
+/**
+ * Props for the drop zone container element.
+ */
+interface DropZoneProps {
+    onDragEnter: (e: React$1.DragEvent) => void;
+    onDragOver: (e: React$1.DragEvent) => void;
+    onDragLeave: (e: React$1.DragEvent) => void;
+    onDrop: (e: React$1.DragEvent) => void;
+}
+interface UseFileUploadOptions {
+    /** Configuration for file uploads. If undefined, file upload is disabled. */
+    config?: FileUploadConfig;
+    /** Whether file operations should be disabled (e.g., during loading) */
+    disabled?: boolean;
+    /** Dependency that resets attachments when changed (e.g., currentChatId) */
+    resetDependency?: unknown;
+}
+interface UseFileUploadReturn {
+    /** Current file attachments */
+    attachments: FileAttachment[];
+    /** Whether a drag operation is in progress over the drop zone */
+    isDragging: boolean;
+    /** Current file error message, if any */
+    fileError: string | null;
+    /** Whether file upload is enabled */
+    enabled: boolean;
+    /** Maximum file size in bytes */
+    maxFileSize: number;
+    /** Accepted MIME types */
+    acceptedTypes?: string[];
+    /** Ref to attach to hidden file input */
+    fileInputRef: React$1.MutableRefObject<HTMLInputElement | null>;
+    /** Validates and adds files to attachments */
+    handleFiles: (files: FileList | File[]) => Promise<void>;
+    /** Removes a file attachment by ID */
+    removeAttachment: (id: string) => void;
+    /** Clears all attachments */
+    clearAttachments: () => void;
+    /** Opens the file picker dialog */
+    openFilePicker: () => void;
+    /** Handler for file input change event */
+    handleFileInputChange: (e: React$1.ChangeEvent<HTMLInputElement>) => void;
+    /** Handler for dragenter event (use with dragover/dragleave/drop) */
+    handleDragEnter: (e: React$1.DragEvent) => void;
+    /** Handler for dragover event */
+    handleDragOver: (e: React$1.DragEvent) => void;
+    /** Handler for dragleave event */
+    handleDragLeave: (e: React$1.DragEvent) => void;
+    /** Handler for drop event */
+    handleDrop: (e: React$1.DragEvent) => void;
+    /** Props to spread on the drop zone container element */
+    getDropZoneProps: () => DropZoneProps;
+    /** Overlay component to render inside the drop zone container (shows when dragging) */
+    DropZoneOverlay: React$1.ReactNode;
+}
+/**
+ * Hook for managing file uploads with drag-and-drop support.
+ *
+ * Features:
+ * - File validation (size, type)
+ * - Image preview generation
+ * - Drag and drop handling
+ * - Auto-clearing error messages
+ * - Reset on dependency change (e.g., chat switch)
+ *
+ * @example
+ * ```typescript
+ * const {
+ *   attachments,
+ *   isDragging,
+ *   fileError,
+ *   fileInputRef,
+ *   handleDragOver,
+ *   handleDragLeave,
+ *   handleDrop,
+ *   openFilePicker,
+ *   handleFileInputChange,
+ *   removeAttachment,
+ * } = useFileUpload({
+ *   config: fileUploadConfig,
+ *   disabled: loading,
+ *   resetDependency: currentChatId,
+ * });
+ * ```
+ */
+declare function useFileUpload({ config, disabled, resetDependency, }: UseFileUploadOptions): UseFileUploadReturn;
+
+/**
+ * LocalStorage-based implementation of CommandRepository.
+ * Stores commands in browser localStorage with an index for efficient listing.
+ */
+declare class LocalStorageCommandRepository implements CommandRepository {
+    private storage;
+    private maxCommands;
+    constructor(storage?: Storage, maxCommands?: number);
+    createCommand(options: CreateCommandOptions): Promise<string>;
+    loadCommand(id: string): Promise<SavedCommand | null>;
+    loadCommandByName(name: string): Promise<SavedCommand | null>;
+    updateCommand(command: SavedCommand): Promise<void>;
+    deleteCommand(id: string): Promise<void>;
+    listCommands(options?: ListCommandsOptions): Promise<SavedCommand[]>;
+    deleteAll(): Promise<void>;
+    private saveCommandToStorage;
+    private deserializeCommand;
+    private getIndex;
+    private addToIndex;
+    private removeFromIndex;
+    private enforceMaxCommandsLimit;
+}
+
+/**
+ * Options for the useSlashCommands hook.
+ */
+interface UseSlashCommandsOptions {
+    /** List of saved slash commands */
+    commands: SavedCommand[];
+    /** Callback when a command is selected (via click or keyboard) */
+    onCommandSelect?: (text: string) => void;
+    /** Callback to save a new command */
+    onSaveCommand?: (name: string, text: string) => Promise<string>;
+    /** Callback to rename an existing command */
+    onRenameCommand?: (id: string, newName: string) => Promise<void>;
+    /** Callback to delete a command */
+    onDeleteCommand?: (id: string) => Promise<void>;
+}
+/**
+ * Props for the inline save UI component.
+ */
+interface InlineSaveProps {
+    /** The message ID being saved */
+    messageId: string;
+    /** The text content of the message */
+    messageText: string;
+}
+/**
+ * Return value from the useSlashCommands hook.
+ */
+interface UseSlashCommandsReturn {
+    /** Whether the autocomplete dropdown is visible */
+    isAutocompleteVisible: boolean;
+    /**
+     * Process input changes to detect slash command prefix.
+     * Returns true if the input starts with '/' and autocomplete was triggered.
+     */
+    handleInputChange: (value: string) => boolean;
+    /**
+     * Process keyboard events for autocomplete navigation.
+     * Returns true if the event was handled by the hook.
+     * When a command is selected via Enter, onCommandSelect will be called.
+     */
+    handleKeyDown: (e: React$1.KeyboardEvent) => boolean;
+    /**
+     * Manually close the autocomplete dropdown.
+     */
+    closeAutocomplete: () => void;
+    /**
+     * Renders the autocomplete dropdown component.
+     * Returns null if autocomplete should not be shown.
+     */
+    AutocompleteComponent: React$1.ReactNode;
+    /**
+     * Start saving a message as a slash command.
+     */
+    startSavingCommand: (messageId: string, messageText: string) => void;
+    /**
+     * Check if a specific message is currently being saved as a command.
+     */
+    isSavingCommand: (messageId: string) => boolean;
+    /**
+     * Cancel the inline save operation.
+     */
+    cancelInlineSave: () => void;
+    /**
+     * Renders the inline save UI component for a specific message.
+     * Returns null if not saving for this message.
+     */
+    renderInlineSaveUI: (props: InlineSaveProps) => React$1.ReactNode;
+}
+/**
+ * Composable hook for slash commands functionality.
+ * Manages autocomplete state, keyboard navigation, and inline save operations.
+ *
+ * @example
+ * ```tsx
+ * const {
+ *   isAutocompleteVisible,
+ *   handleInputChange,
+ *   handleKeyDown,
+ *   AutocompleteComponent,
+ *   startSavingCommand,
+ *   isSavingCommand,
+ *   renderInlineSaveUI,
+ * } = useSlashCommands({
+ *   commands,
+ *   onCommandSelect: (text) => setInput(text),
+ *   onSaveCommand,
+ *   onDeleteCommand,
+ * });
+ *
+ * // In your input handler
+ * const onInputChange = (e) => {
+ *   const value = e.target.value;
+ *   setInput(value);
+ *   handleInputChange(value);
+ * };
+ *
+ * // In your keydown handler
+ * const onKeyDown = (e) => {
+ *   if (handleKeyDown(e)) {
+ *     return; // Event was handled by slash commands
+ *   }
+ *   // Handle other key events...
+ * };
+ *
+ * // Render
+ * return (
+ *   <div style={{ position: 'relative' }}>
+ *     {AutocompleteComponent}
+ *     <textarea ... />
+ *   </div>
+ * );
+ * ```
+ */
+declare function useSlashCommands({ commands, onCommandSelect, onSaveCommand, onRenameCommand, onDeleteCommand, }: UseSlashCommandsOptions): UseSlashCommandsReturn;
+
+interface UseChatManagementOptions {
+    /** Chat repository for persistence */
+    repository: ChatRepository;
+    /** Reference to the UseAIClient (can be null during initialization) */
+    clientRef: React.MutableRefObject<UseAIClient | null>;
+}
+interface UseChatManagementReturn {
+    /** Current active chat ID where AI responses are saved */
+    currentChatId: string | null;
+    /** Chat loaded for viewing but not yet active for AI responses */
+    pendingChatId: string | null;
+    /** Current messages in the chat */
+    messages: Message[];
+    /** The displayed chat ID (pending or current) */
+    displayedChatId: string | null;
+    /** Creates a new chat and switches to it */
+    createNewChat: () => Promise<string>;
+    /** Loads an existing chat by ID */
+    loadChat: (chatId: string) => Promise<void>;
+    /** Deletes a chat by ID */
+    deleteChat: (chatId: string) => Promise<void>;
+    /** Lists all available chats */
+    listChats: () => Promise<Array<Omit<Chat, 'messages'>>>;
+    /** Clears the current chat messages */
+    clearCurrentChat: () => Promise<void>;
+    /** Activates the pending chat (called when user sends first message) */
+    activatePendingChat: () => string | null;
+    /** Saves a user message to storage and reloads messages */
+    saveUserMessage: (chatId: string, content: PersistedMessageContent) => Promise<boolean>;
+    /** Saves an AI response to storage and optionally reloads messages */
+    saveAIResponse: (content: string, displayMode?: 'default' | 'error') => Promise<void>;
+    /** Reloads messages from storage for the given chat ID */
+    reloadMessages: (chatId: string) => Promise<void>;
+    /** Snapshot refs for use in event handlers */
+    currentChatIdSnapshot: React.MutableRefObject<string | null>;
+    pendingChatIdSnapshot: React.MutableRefObject<string | null>;
+}
+/**
+ * Hook for managing chat lifecycle operations.
+ *
+ * Features:
+ * - Creates, loads, deletes chats
+ * - Manages pending/active chat state machine
+ * - Saves user messages and AI responses
+ * - Auto-generates chat titles
+ * - Initializes with most recent chat or creates new one
+ *
+ * @example
+ * ```typescript
+ * const {
+ *   currentChatId,
+ *   pendingChatId,
+ *   messages,
+ *   createNewChat,
+ *   loadChat,
+ *   deleteChat,
+ *   listChats,
+ *   clearCurrentChat,
+ *   activatePendingChat,
+ *   saveUserMessage,
+ *   saveAIResponse,
+ * } = useChatManagement({
+ *   repository: chatRepository,
+ *   clientRef,
+ * });
+ * ```
+ */
+declare function useChatManagement({ repository, clientRef, }: UseChatManagementOptions): UseChatManagementReturn;
+
+interface UseAgentSelectionOptions {
+    /** Reference to the UseAIClient (can be null during initialization) */
+    clientRef: React.MutableRefObject<UseAIClient | null>;
+    /** Whether the client is connected (triggers subscription when true) */
+    connected: boolean;
+    /**
+     * Optional list of agent IDs to show in the UI.
+     * When provided, only agents with these IDs will be shown (if they exist on the server).
+     * If the list is empty or no agents match, falls back to the default agent.
+     */
+    visibleAgentIds?: AgentInfo['id'][];
+}
+interface UseAgentSelectionReturn {
+    /** List of available agents from the server */
+    availableAgents: AgentInfo[];
+    /** The default agent ID from the server */
+    defaultAgent: string | null;
+    /** The currently selected agent ID (null means use server default) */
+    selectedAgent: string | null;
+    /** Sets the agent to use for requests (null to use server default) */
+    setAgent: (agentId: string | null) => void;
+}
+/**
+ * Hook for managing agent selection state.
+ *
+ * Features:
+ * - Subscribes to agent changes from the server
+ * - Tracks available agents, default agent, and user selection
+ * - Syncs selection state with the WebSocket client
+ * - Filters agents based on visibleAgentIds (list of IDs)
+ *
+ * @example
+ * ```typescript
+ * const {
+ *   availableAgents,
+ *   defaultAgent,
+ *   selectedAgent,
+ *   setAgent,
+ * } = useAgentSelection({ clientRef, connected });
+ *
+ * // Select a specific agent
+ * setAgent('claude-3-5-sonnet');
+ *
+ * // Reset to server default
+ * setAgent(null);
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // With visibleAgentIds to filter agents by ID
+ * const {
+ *   availableAgents, // Only includes agents with these IDs
+ * } = useAgentSelection({
+ *   clientRef,
+ *   connected,
+ *   visibleAgentIds: ['claude-sonnet', 'claude-opus']
+ * });
+ * ```
+ */
+declare function useAgentSelection({ clientRef, connected, visibleAgentIds, }: UseAgentSelectionOptions): UseAgentSelectionReturn;
+
+interface UseCommandManagementOptions {
+    /** Custom command repository. Defaults to LocalStorageCommandRepository. */
+    repository?: CommandRepository;
+}
+interface UseCommandManagementReturn {
+    /** List of saved slash commands */
+    commands: SavedCommand[];
+    /** Refreshes the commands list from storage */
+    refreshCommands: () => Promise<void>;
+    /** Saves a new command */
+    saveCommand: (name: string, text: string) => Promise<string>;
+    /** Renames an existing command */
+    renameCommand: (id: string, newName: string) => Promise<void>;
+    /** Deletes a command by ID */
+    deleteCommand: (id: string) => Promise<void>;
+}
+/**
+ * Hook for managing slash commands persistence.
+ *
+ * Features:
+ * - CRUD operations for slash commands
+ * - Auto-loads commands on mount
+ * - Uses LocalStorageCommandRepository by default
+ *
+ * @example
+ * ```typescript
+ * const {
+ *   commands,
+ *   refreshCommands,
+ *   saveCommand,
+ *   renameCommand,
+ *   deleteCommand,
+ * } = useCommandManagement();
+ *
+ * // Save a new command
+ * await saveCommand('greet', 'Hello, how can I help you today?');
+ *
+ * // Rename a command
+ * await renameCommand(commandId, 'greeting');
+ *
+ * // Delete a command
+ * await deleteCommand(commandId);
+ * ```
+ */
+declare function useCommandManagement({ repository, }?: UseCommandManagementOptions): UseCommandManagementReturn;
+
+interface RegisterToolsOptions {
+    /** Mark component as invisible (no visual state, skip prompt wait) */
+    invisible?: boolean;
+}
+interface UseToolRegistryReturn {
+    /** Registers tools for a specific component */
+    registerTools: (id: string, tools: ToolsDefinition, options?: RegisterToolsOptions) => void;
+    /** Unregisters tools for a specific component */
+    unregisterTools: (id: string) => void;
+    /** Checks if a component is marked as invisible */
+    isInvisible: (id: string) => boolean;
+    /** All tools aggregated from registered components */
+    aggregatedTools: ToolsDefinition;
+    /** Whether any tools are registered */
+    hasTools: boolean;
+    /** Ref to current aggregated tools (for use in closures) */
+    aggregatedToolsRef: React.MutableRefObject<ToolsDefinition>;
+    /** Ref mapping tool names to component IDs */
+    toolOwnershipRef: React.MutableRefObject<Map<string, string>>;
+}
+/**
+ * Hook for managing tool registration and aggregation.
+ *
+ * Only handles tools - prompt management is handled separately.
+ */
+declare function useToolRegistry(): UseToolRegistryReturn;
+
+interface UsePromptStateOptions {
+    /** System prompt to include in state */
+    systemPrompt?: string;
+    /** Reference to the UseAIClient for state updates */
+    clientRef: React.MutableRefObject<UseAIClient | null>;
+    /** Whether the client is connected to the server */
+    connected: boolean;
+}
+interface UsePromptStateReturn {
+    /** Updates the prompt and suggestions for a specific component */
+    updatePrompt: (id: string, prompt?: string, suggestions?: string[]) => void;
+    /** Registers a waiter function for a component */
+    registerWaiter: (id: string, waiter: () => Promise<void>) => void;
+    /** Unregisters a waiter function */
+    unregisterWaiter: (id: string) => void;
+    /** Gets the waiter function for a component */
+    getWaiter: (id: string) => (() => Promise<void>) | undefined;
+    /** All suggestions aggregated from registered components */
+    aggregatedSuggestions: string[];
+    /** Ref mapping component IDs to prompts */
+    promptsRef: React.MutableRefObject<Map<string, string>>;
+}
+/**
+ * Hook for managing prompt state across multiple useAI hooks.
+ *
+ * Handles:
+ * - Storing prompts and suggestions per component
+ * - Updating client state when prompts change
+ * - Managing waiter functions for prompt change notifications
+ * - Aggregating suggestions from all components
+ */
+declare function usePromptState({ systemPrompt, clientRef, connected, }: UsePromptStateOptions): UsePromptStateReturn;
+
+/**
+ * Creates stable tool references that maintain fresh closures.
+ *
+ * This hook solves the "render loop" problem that occurs when users define tools
+ * inline without memoization. It ensures that:
+ *
+ * 1. Tool object references remain stable as long as tool names don't change
+ * 2. Handler calls are proxied through refs to always use the latest closure
+ * 3. Metadata (description, schema, confirmationRequired) updates in-place
+ *
+ * @param tools - The tools definition from the user (potentially unstable references)
+ * @returns Stabilized tools definition that won't cause effect re-runs
+ *
+ * @example
+ * ```typescript
+ * // Previously problematic - caused render loops
+ * useAI({
+ *   tools: {
+ *     updateState: defineTool('Update state', z.object({ value: z.string() }),
+ *       (input) => setState(input.value)  // Closure recreated every render
+ *     ),
+ *   },
+ * });
+ *
+ * // Now works correctly - useStableTools handles stabilization internally
+ * ```
+ */
+declare function useStableTools(tools: ToolsDefinition | undefined): ToolsDefinition | undefined;
+
+/**
+ * Return value from useDropdownState hook.
+ */
+interface UseDropdownStateReturn {
+    /** Whether the dropdown is currently open */
+    isOpen: boolean;
+    /** Opens the dropdown */
+    open: () => void;
+    /** Closes the dropdown */
+    close: () => void;
+    /** Toggles the dropdown open/closed */
+    toggle: () => void;
+    /**
+     * Backdrop element that closes dropdown when clicked.
+     * Render this as a sibling to the dropdown content (both inside a container).
+     * Returns null when dropdown is closed.
+     */
+    Backdrop: React$1.ReactNode;
+}
+interface UseDropdownStateOptions {
+    /** z-index for the backdrop (default: 1002) */
+    backdropZIndex?: number;
+    /** Initial open state (default: false) */
+    initialOpen?: boolean;
+}
+/**
+ * Hook for managing dropdown open/close state with click-outside handling.
+ *
+ * Provides a reusable pattern for dropdowns that:
+ * - Track open/close state
+ * - Close when clicking outside (via backdrop)
+ *
+ * @example
+ * ```typescript
+ * const dropdown = useDropdownState();
+ *
+ * return (
+ *   <div style={{ position: 'relative' }}>
+ *     <button onClick={dropdown.toggle}>Toggle</button>
+ *
+ *     {dropdown.isOpen && (
+ *       <div className="dropdown-content">
+ *         Dropdown content here
+ *       </div>
+ *     )}
+ *
+ *     {dropdown.Backdrop}
+ *   </div>
+ * );
+ * ```
+ */
+declare function useDropdownState(options?: UseDropdownStateOptions): UseDropdownStateReturn;
+
+export { type AgentContextValue, type Chat, type ChatContextValue, type ChatPanelProps, type ChatRepository, CloseButton, type CommandContextValue, type CommandRepository, type CreateChatOptions, type CreateCommandOptions, DEFAULT_MAX_FILE_SIZE, type DefinedTool, type DropZoneProps, EmbedFileUploadBackend, type FileAttachment, type FileUploadBackend, type FileUploadConfig, type FloatingButtonProps, type InlineSaveProps, type ListChatsOptions, type ListCommandsOptions, LocalStorageChatRepository, LocalStorageCommandRepository, type Message, type PersistedContentPart, type PersistedFileContent, type PersistedFileMetadata, type PersistedMessage, type PersistedMessageContent, type PersistedTextContent, type PromptsContextValue, type RegisterToolsOptions, type SavedCommand, type ToolOptions, type ToolRegistryContextValue, type ToolsDefinition, type TriggerWorkflowOptions, UseAIChat, UseAIChatPanel, type UseAIChatPanelProps, type UseAIChatPanelStrings, type UseAIChatPanelTheme, type UseAIChatProps, UseAIClient, type UseAIConfig, type UseAIContextValue, UseAIFloatingButton, UseAIFloatingChatWrapper, type UseAIOptions, UseAIProvider, type UseAIProviderProps, type UseAIResult, type UseAIStrings, type UseAITheme, type UseAIWorkflowResult, type UseAgentSelectionOptions, type UseAgentSelectionReturn, type UseChatManagementOptions, type UseChatManagementReturn, type UseCommandManagementOptions, type UseCommandManagementReturn, type UseDropdownStateOptions, type UseDropdownStateReturn, type UseFileUploadOptions, type UseFileUploadReturn, type UsePromptStateOptions, type UsePromptStateReturn, type UseSlashCommandsOptions, type UseSlashCommandsReturn, type UseToolRegistryReturn, type WorkflowProgress, convertToolsToDefinitions, defaultStrings, defaultTheme, defineTool, executeDefinedTool, generateChatId, generateCommandId, generateMessageId, useAI, useAIContext, useAIWorkflow, useAgentSelection, useChatManagement, useCommandManagement, useDropdownState, useFileUpload, usePromptState, useSlashCommands, useStableTools, useStrings, useTheme, useToolRegistry, validateCommandName };